ItemSpec

Instance\ProjectItemInstance.cs (2)

299string ITaskItem.ItemSpec 924public string ItemSpec

TaskParameter.cs (1)

BackEnd\TaskRegistry_Tests.cs (1)

2133public string ItemSpec { get; set; }

BackEnd\TaskThatReturnsDictionaryTaskItem.cs (1)

44public string ItemSpec { get => $"{nameof(MinimalDictionaryTaskItem)}spec"; set => throw new NotImplementedException(); }

MockTask.cs (1)

428public string ItemSpec { get; set; }

TaskThatReturnsMinimalItem.cs (1)

30public string ItemSpec { get => $"{nameof(MinimalTaskItem)}spec"; set => throw new NotImplementedException(); }

TaskItemData.cs (1)

21public string ItemSpec { get; set; }

TestUtilities\SimpleTaskItem.cs (1)

14public string ItemSpec { get; set; }

TaskParameter.cs (1)

649public string ItemSpec

CommandLineGenerator_Tests.cs (1)

167public string ItemSpec

GenerateBindingRedirects_Tests.cs (1)

388string ITaskItem.ItemSpec { get; set; }

XslTransformation_Tests.cs (1)

1344public string ItemSpec { get; set; } = null;

TaskItem.cs (1)

180public string ItemSpec

TaskParameter.cs (1)

649public string ItemSpec

BackEnd\TaskParameter.cs (1)

577public string ItemSpec

BackEnd\Components\RequestBuilder\IntrinsicTasks\MSBuild.cs (1)

699outputItemFromTarget.ItemSpec = Path.Combine(projectDirectory[i], outputItemFromTarget.ItemSpec);

Instance\ProjectInstance_Tests.cs (1)

758Helpers.VerifyAssertThrowsInvalidOperation(delegate () { ((ITaskItem2)Helpers.GetFirst(instance.Items)).ItemSpec = "x"; });

src\Compilers\Core\MSBuildTask\ManagedCompiler.cs (4)

861OutputAssembly.ItemSpec += ".dll"; 865OutputAssembly.ItemSpec += ".netmodule"; 869OutputAssembly.ItemSpec += ".exe"; 1101item.ItemSpec = Utilities.GetFullPathNoThrow(item.ItemSpec);

src\Compilers\Core\MSBuildTask\MapSourceRoots.cs (1)

112sourceRoot.ItemSpec = NormalizePath(sourceRoot.ItemSpec);

src\Compilers\Core\MSBuildTask\ManagedCompiler.cs (4)

861OutputAssembly.ItemSpec += ".dll"; 865OutputAssembly.ItemSpec += ".netmodule"; 869OutputAssembly.ItemSpec += ".exe"; 1101item.ItemSpec = Utilities.GetFullPathNoThrow(item.ItemSpec);

src\Compilers\Core\MSBuildTask\MapSourceRoots.cs (1)

112sourceRoot.ItemSpec = NormalizePath(sourceRoot.ItemSpec);

AssemblyDependency\ResolveAssemblyReference.cs (1)

ConvertToAbsolutePath.cs (1)

65path.ItemSpec = EscapingUtilities.Escape(path.GetMetadata("FullPath"));

ListOperators\FindUnderPath.cs (1)

125item.ItemSpec = EscapingUtilities.Escape(fullPath);

MSBuild.cs (1)

642outputItemFromTarget.ItemSpec = Path.Combine(projectDirectory[i], outputItemFromTarget.ItemSpec);

ResolveComReference.cs (1)

908referencePathItem.ItemSpec = wrapperInfo.path;

ResolveNativeReference.cs (6)

239itemNativeReferenceFile.ItemSpec = path; 270item.ItemSpec = id; 291itemLooseEtcFile.ItemSpec = fileref.ResolvedPath; 308itemComClass.ItemSpec = comclass.ClsId; 322itemTypeLib.ItemSpec = typelib.TlbId; 338itemLooseTlbFile.ItemSpec = fileref.ResolvedPath;

AssignLinkMetadata_Tests.cs (1)

46item.ItemSpec = "|||";

GenerateBindingRedirects_Tests.cs (1)

382((ITaskItem)this).ItemSpec = assemblyName;

ResourceHandling\ResGen_Tests.cs (3)

194a.ItemSpec = "foo.dll"; 195b.ItemSpec = "bar.dll"; 303lastReference.ItemSpec = referencePathBuilder.ToString();

src\CreateWixBuildWixpack.cs (4)

287IntermediateDirectory.ItemSpec = "%outputfolder%"; 292PdbFile.ItemSpec = Path.Combine("%outputfolder%", Path.GetFileName(PdbFile.ItemSpec)); 298BindTrackingFile.ItemSpec = Path.Combine("%outputfolder%", Path.GetFileName(BindTrackingFile.ItemSpec)); 1070BindPaths[i].ItemSpec = wixpackSubfolder;

GetNonExecutableReferences.cs (1)

38Log.LogMessage(MessageImportance.Low, $"Skipping project '{appProject.ItemSpec}' because it does not contain AdditionalPropertiesFromProject metadata.");

PrepareForReadyToRunCompilation.cs (9)

193using (FileStream fs = new(file.ItemSpec, FileMode.Open, FileAccess.Read)) 278MainAssembly.SetMetadata(MetadataKeys.RelativePath, Path.GetFileName(MainAssembly.ItemSpec)); 300ItemSpec = r2rCompositeInputList[0].ItemSpec 437if (!file.ItemSpec.EndsWith(".dll", StringComparison.OrdinalIgnoreCase) && !file.ItemSpec.EndsWith(".exe", StringComparison.OrdinalIgnoreCase)) 443using (FileStream fs = new(file.ItemSpec, FileMode.Open, FileAccess.Read)) 466bool excludeFromR2R = (exclusionSet != null && exclusionSet.Contains(Path.GetFileName(file.ItemSpec))); 467bool excludeFromComposite = (r2rCompositeExclusionSet != null && r2rCompositeExclusionSet.Contains(Path.GetFileName(file.ItemSpec))) || excludeFromR2R; 471bool rootedInComposite = (r2rCompositeRootSet == null || r2rCompositeRootSet.Contains(Path.GetFileName(file.ItemSpec)));

RunReadyToRunCompiler.cs (15)

64return Crossgen2Tool.ItemSpec; 66return CrossgenTool.ItemSpec; 103if (!File.Exists(Crossgen2Tool.ItemSpec)) 105Log.LogError(Strings.Crossgen2ToolExecutableNotFound, Crossgen2Tool.ItemSpec); 151if (!File.Exists(CrossgenTool.ItemSpec)) 153Log.LogError(Strings.CrossgenToolExecutableNotFound, CrossgenTool.ItemSpec); 167_outputR2RImage = CompilationEntry.ItemSpec; 193_inputAssembly = CompilationEntry.ItemSpec; 231if (IsPdbCompilation && string.Equals(Path.GetFileName(reference.ItemSpec), Path.GetFileName(_outputR2RImage), StringComparison.OrdinalIgnoreCase)) 236result.AppendLine($"-r:\"{reference.ItemSpec}\""); 240result.AppendLine($"-r \"{reference.ItemSpec}\""); 252return $"\"{Crossgen2Tool.ItemSpec}\""; 342result.AppendLine($"-m:\"{mibc.ItemSpec}\""); 375result.AppendLine(reference.ItemSpec); 382result.AppendLine($"-u:\"{unrooted.ItemSpec}\"");

CombineLinkerXmlFiles.cs (1)

33XDocument subFile = XDocument.Load(linkerXmlFile.ItemSpec);

ComputeManagedAssemblies.cs (1)

29.Where(f => Utils.IsManagedAssembly(f.ItemSpec))

CreateRuntimeRootDescriptorFile.cs (7)

102var namespaceFilePath = NamespaceFilePath.ItemSpec; 109var mscorlibFilePath = MscorlibFilePath.ItemSpec; 116var cortypeFilePath = CortypeFilePath.ItemSpec; 123var rexcepFilePath = RexcepFilePath.ItemSpec; 132var iLLinkTrimXmlFilePath = ILLinkTrimXmlFilePath.ItemSpec; 147OutputXml(iLLinkTrimXmlFilePath, RuntimeRootDescriptorFilePath.ItemSpec); 556defineConstants.Add(item.ItemSpec.Trim());

LinkTask.cs (9)

316args.Append("-x ").AppendLine(Quote(rootFile.ItemSpec)); 321args.Append("-a ").Append(Quote(assemblyItem.ItemSpec)); 363var assemblyPath = assembly.ItemSpec; 425var assemblyPath = assembly.ItemSpec; 443args.Append("-out ").AppendLine(Quote(OutputDirectory.ItemSpec)); 485var key = customData.ItemSpec; 497var feature = featureSetting.ItemSpec; 508args.Append("--keep-metadata ").AppendLine(Quote(metadata.ItemSpec)); 522var stepPath = customStep.ItemSpec;

GenerateFileVersionProps.cs (2)

59var fileName = Path.GetFileName(file.ItemSpec); 110.Select(p => p.Value.File.ItemSpec)

StaticFileRegeneration\RegenerateThirdPartyNotices.cs (2)

54string repo = item.ItemSpec; 56?? throw new ArgumentException($"{item.ItemSpec} specifies no Branch.");

BackEnd\Components\Communications\LogMessagePacket.cs (1)

242writer.Write(taskItem.ItemSpec);

BackEnd\Components\RequestBuilder\IntrinsicTasks\ItemGroupLoggingHelper.cs (1)

189sb.Append(item.ItemSpec);

BackEnd\Components\RequestBuilder\IntrinsicTasks\MSBuild.cs (9)

319AbsolutePath projectPath = TaskEnvironment.GetAbsolutePath(FileUtilities.AttemptToShortenPath(project.ItemSpec)); 355Log.LogErrorWithCodeFromResources("MSBuild.ProjectUpgradeNeededToVcxProj", project.ItemSpec); 393Log.LogMessageFromResources(MessageImportance.High, "MSBuild.ProjectFileNotFoundMessage", project.ItemSpec); 398Log.LogErrorWithCodeFromResources("MSBuild.ProjectFileNotFound", project.ItemSpec); 561string projectPath = FileUtilities.AttemptToShortenPath(projects[i].ItemSpec); 563projectNames[i] = projects[i].ItemSpec; 699outputItemFromTarget.ItemSpec = Path.Combine(projectDirectory[i], outputItemFromTarget.ItemSpec); 703log.LogWarningWithCodeFromResources(null, projects[i].ItemSpec, 0, 0, 0, 0, "MSBuild.CannotRebaseOutputItemPath", outputItemFromTarget.ItemSpec, e.Message);

BackEnd\Components\RequestBuilder\TaskBuilder.cs (1)

1071var normalizedMSBuildProject = FileUtilities.NormalizePath(msbuildProject.ItemSpec);

BackEnd\TaskExecutionHost\TaskExecutionHost.cs (2)

1526newItem = new ProjectItemInstance(_projectInstance, outputTargetName, EscapingUtilities.Escape(output.ItemSpec), parameterLocationEscaped); 1599joinedOutputs.Append(EscapingUtilities.Escape(output.ItemSpec));

BuildCheck\OM\ParsedItemsCheckData.cs (1)

133yield return taskItem.ItemSpec;

Logging\BaseConsoleLogger.cs (3)

112((ITaskItem)a).ItemSpec, 113((ITaskItem)b).ItemSpec, 623ITaskItem taskItem => taskItem.ItemSpec,

Logging\BinaryLogger\BuildEventArgsWriter.cs (3)

1051if (item is ITaskItem taskItem && !string.IsNullOrEmpty(taskItem.ItemSpec)) 1053EmbedFile.Invoke(taskItem.ItemSpec); 1064WriteDeduplicatedString(item.ItemSpec);

Logging\ParallelLogger\ParallelConsoleLogger.cs (2)

610ITaskItem taskItem => taskItem.ItemSpec, // ProjectItemInstance 895WriteMessageAligned(ResourceUtilities.FormatResourceStringStripCodeAndKeyword("TargetOutputItem", item.ItemSpec), false);

Logging\TerminalLogger\TerminalLogger.cs (2)

1113project.OutputPath = output.ItemSpec.AsMemory(); 1126?.ItemSpec.AsMemory();

TaskParameter.cs (1)

595_escapedItemSpec = EscapingUtilities.Escape(copyFrom.ItemSpec);

TaskInvocationAnalysisDataTests.cs (2)

150((ITaskItem)listValue[0]!).ItemSpec.ShouldBe("item1"); 151((ITaskItem)listValue[1]!).ItemSpec.ShouldBe("item2");

Instance\ProjectItemInstance_Tests.cs (3)

324Assert.Equal(item.EvaluatedInclude, taskItem.ItemSpec); 349Assert.Equal("esca ped;item", taskItem.ItemSpec); 356Assert.Equal("esca ped;item", taskItem.ItemSpec);

BackEnd\BuildManager_Tests.cs (5)

454Assert.True(int.TryParse(item[2].ItemSpec, out int processId), $"Process ID passed from the 'test' target is not a valid integer (actual is '{item[2].ItemSpec}')"); 3769Assert.Equal("InitialValue", results.ResultsByTarget["BuildOther"].Items.First().ItemSpec); 3791Assert.Equal(newPropertyValue, results.ResultsByTarget["Foo"].Items.First().ItemSpec); 3855string.Join(";", result.ResultsByTarget["MainTarget"].Items.Select(i => i.ItemSpec)));

BackEnd\MSBuild_Tests.cs (5)

1812Assert.Equal("|a", targetOutputs["Build"].Items[0].ItemSpec); 1813Assert.Equal("A|b", targetOutputs["Build"].Items[1].ItemSpec); 1814Assert.Equal("B|c", targetOutputs["Build"].Items[2].ItemSpec); 1815Assert.Equal("C|d", targetOutputs["Build"].Items[3].ItemSpec); 1816Assert.Equal("D|", targetOutputs["Build"].Items[4].ItemSpec);

BackEnd\SdkResultOutOfProc_Tests.cs (3)

177int.TryParse(item[0].ItemSpec, out int processId) 178.ShouldBeTrue($"Process ID passed from the 'test' target is not a valid integer (actual is '{item[0].ItemSpec}')"); 189.Select(i => i.ItemSpec)

BackEnd\TargetEntry_Tests.cs (5)

380Assert.Equal("foo.o", results.Items[0].ItemSpec); 400Assert.Equal("testProject.proj", results.Items[0].ItemSpec); 696Assert.Equal("item1", outputListB[0].ItemSpec); 708Assert.Equal("item1", outputListB[0].ItemSpec); 712Assert.Equal("item2", outputListC[0].ItemSpec);

BackEnd\TargetResult_Tests.cs (1)

43Assert.Equal(item.ItemSpec, result.Items[0].ItemSpec);

BackEnd\TaskExecutionHost_Tests.cs (6)

866ValidateOutputProperty("ItemOutput", _oneItem[0].ItemSpec); 886ValidateOutputProperty("ItemArrayOutput", String.Concat(_twoItems[0].ItemSpec, ";", _twoItems[1].ItemSpec)); 1382Assert.Equal(value, actualItem.ItemSpec); 1410Assert.Equal(value, actualItems[0].ItemSpec); 1445Assert.Equal(expectedItems[i], actualItems[i].ItemSpec);

BackEnd\TaskHostConfiguration_Tests.cs (2)

762Assert.Equal(x.ItemSpec, y.ItemSpec);

BackEnd\TranslationHelpers.cs (1)

236sb.Append(taskItem.ItemSpec);

BuildEventArgsSerialization_Tests.cs (1)

1261return i.ItemSpec + string.Join(";", i.CloneCustomMetadata().Keys.OfType<string>().Select(k => i.GetMetadata(k)));

Construction\SolutionProjectGenerator_Tests.cs (5)

1327if (item.ItemSpec.EndsWith("ClassLibrary1.csproj")) 1331else if (item.ItemSpec.EndsWith("MainApp.metaproj")) 1335else if (item.ItemSpec == "Debug|Mixed Platforms") 1341else if (item.ItemSpec == "Release|Any CPU") 1349Assert.Fail("Unexpected project seen:" + item.ItemSpec);

EscapingInProjects_Tests.cs (1)

57Log.LogMessageFromText("Received TaskItemParam: " + TaskItemParam.ItemSpec, MessageImportance.High);

FixPathOnUnix_Tests.cs (1)

66Log.LogMessage($"Item: {item.ItemSpec}");

Graph\IsolateProjects_Tests.cs (1)

364declaredReferenceBuildResults[0]["DeclaredReferenceTarget"].Items[0].ItemSpec.ShouldBe("Foo.cs");

Graph\ResultCacheBasedBuilds_Tests.cs (4)

141.ItemSpec.ShouldBe("1"); 172resultFromCachedBuild.ResultsByTarget["Build"].Items.First().ItemSpec.ShouldBe("1"); 362rootNodeBuildResult.ResultsByTarget["Build"].Items.Select(i => i.ItemSpec).ToArray().ShouldBe(expectedOutput[rootNode]); 481var actualOutput = result.ResultsByTarget["Build"].Items.Select(i => i.ItemSpec).ToArray();

ProjectCache\ProjectCacheTests.cs (1)

882itemResult.ItemSpec.ShouldBe(GetProjectNumber(projectPath).ToString());

TaskParameter_Tests.cs (22)

TestComparers\TaskItemComparer.cs (2)

41if (x.ItemSpec != y.ItemSpec)

IItemData.cs (1)

58EvaluatedInclude = ti.ItemSpec;

TaskItemData.cs (1)

36ItemSpec = original.ItemSpec;

TaskParameterEventArgs.cs (1)

213writer.Write(taskItem.ItemSpec);

Utilities\MetadataConversionUtilities.cs (1)

44throw new ArgumentException(SR.FormatInvalidAttributeMetadata(item.ItemSpec, itemMetadataName, metadataValue, "bool"), e);

src\Compilers\Core\MSBuildTask\CommandLineBuilderExtension.cs (1)

248AppendSwitchIfNotNull(switchName, parameter.ItemSpec);

src\Compilers\Core\MSBuildTask\Csc.cs (8)

291commandLine.AppendSwitchIfNotNull("@", response.ItemSpec); 374appendGlobalReference(reference.ItemSpec); 406reference.ItemSpec, 414appendGlobalReference(reference.ItemSpec); 421commandLine.AppendSwitchAliased(switchName, trimmedAlias, reference.ItemSpec); 439commandLine.AppendSwitchForceQuoted(switchName, reference.ItemSpec); 443commandLine.AppendSwitchIfNotNull(switchName, reference.ItemSpec); 588CheckHostObjectSupport(param = nameof(OutputAssembly), cscHostObject.SetOutputAssembly(OutputAssembly?.ItemSpec));

src\Compilers\Core\MSBuildTask\GenerateMSBuildEditorConfig.cs (6)

22/// <see cref="PropertyItems"/> is expected to be a list of items whose <see cref="ITaskItem.ItemSpec"/> is the property name 27/// <see cref="MetadataItems"/> is expected to be a list of items whose <see cref="ITaskItem.ItemSpec"/> represents a file in the 34/// header will be the full path of the item (generated via its<see cref="ITaskItem.ItemSpec"/>), and each section will have a 76.Append(prop.ItemSpec) 109return string.IsNullOrEmpty(FileName.ItemSpec) ? true : WriteMSBuildEditorConfig(); 116var targetFileName = FileName.ItemSpec;

src\Compilers\Core\MSBuildTask\InteractiveCompiler.cs (2)

210commandLine.AppendSwitchIfNotNull("@", response.ItemSpec); 228commandLine.AppendSwitchIfNotNull("@", scriptResponse.ItemSpec);

src\Compilers\Core\MSBuildTask\ManagedCompiler.cs (10)

853OutputAssembly = new TaskItem(Path.GetFileNameWithoutExtension(Sources[0].ItemSpec)); 978commandLine.AppendSwitchIfNotNull("/analyzer:", analyzer.ItemSpec); 991commandLine.AppendSwitchIfNotNull("/additionalfile:", additionalFile.ItemSpec); 1010commandLine.AppendSwitchIfNotNull("/embed:", embeddedFile.ItemSpec); 1024commandLine.AppendSwitchIfNotNull("/analyzerconfig:", analyzerConfigFile.ItemSpec); 1101item.ItemSpec = Utilities.GetFullPathNoThrow(item.ItemSpec); 1127var itemSpec = sources[i].ItemSpec; 1141transformedSources[j] = sources[j].ItemSpec; 1222if (!File.Exists(reference.ItemSpec)) 1225Log.LogErrorWithCodeFromResources("General_ReferenceDoesNotExist", reference.ItemSpec);

src\Compilers\Core\MSBuildTask\MapSourceRoots.cs (8)

106if (!EndsWithDirectorySeparator(sourceRoot.ItemSpec)) 108Log.LogErrorFromResources("MapSourceRoots.PathMustEndWithSlashOrBackslash", Names.SourceRoot, sourceRoot.ItemSpec); 112sourceRoot.ItemSpec = NormalizePath(sourceRoot.ItemSpec); 114if (rootByItemSpec.TryGetValue(sourceRoot.ItemSpec, out var existingRoot)) 121rootByItemSpec.Add(sourceRoot.ItemSpec, sourceRoot); 140string localPath = root.ItemSpec; 212root.SetMetadata(Names.MappedPath, root.ItemSpec); 236Log.LogWarningFromResources("MapSourceRoots.ContainsDuplicate", Names.SourceRoot, left.ItemSpec, metadataName, leftValue, rightValue);

src\Compilers\Core\MSBuildTask\Utilities.cs (1)

54item.ItemSpec, itemMetadataName, metadataValue, "bool");

src\Compilers\Core\MSBuildTask\Vbc.cs (3)

280MovePdbFileIfNecessary(OutputAssembly?.ItemSpec); 565commandLine.AppendSwitchIfNotNull("@", response.ItemSpec); 870CheckHostObjectSupport(param = nameof(OutputAssembly), vbcHostObject.SetOutputAssembly(OutputAssembly?.ItemSpec));

src\Compilers\Core\MSBuildTask\CommandLineBuilderExtension.cs (1)

248AppendSwitchIfNotNull(switchName, parameter.ItemSpec);

src\Compilers\Core\MSBuildTask\Csc.cs (8)

291commandLine.AppendSwitchIfNotNull("@", response.ItemSpec); 374appendGlobalReference(reference.ItemSpec); 406reference.ItemSpec, 414appendGlobalReference(reference.ItemSpec); 421commandLine.AppendSwitchAliased(switchName, trimmedAlias, reference.ItemSpec); 439commandLine.AppendSwitchForceQuoted(switchName, reference.ItemSpec); 443commandLine.AppendSwitchIfNotNull(switchName, reference.ItemSpec); 588CheckHostObjectSupport(param = nameof(OutputAssembly), cscHostObject.SetOutputAssembly(OutputAssembly?.ItemSpec));

src\Compilers\Core\MSBuildTask\GenerateMSBuildEditorConfig.cs (6)

22/// <see cref="PropertyItems"/> is expected to be a list of items whose <see cref="ITaskItem.ItemSpec"/> is the property name 27/// <see cref="MetadataItems"/> is expected to be a list of items whose <see cref="ITaskItem.ItemSpec"/> represents a file in the 34/// header will be the full path of the item (generated via its<see cref="ITaskItem.ItemSpec"/>), and each section will have a 76.Append(prop.ItemSpec) 109return string.IsNullOrEmpty(FileName.ItemSpec) ? true : WriteMSBuildEditorConfig(); 116var targetFileName = FileName.ItemSpec;

src\Compilers\Core\MSBuildTask\InteractiveCompiler.cs (2)

210commandLine.AppendSwitchIfNotNull("@", response.ItemSpec); 228commandLine.AppendSwitchIfNotNull("@", scriptResponse.ItemSpec);

src\Compilers\Core\MSBuildTask\ManagedCompiler.cs (10)

853OutputAssembly = new TaskItem(Path.GetFileNameWithoutExtension(Sources[0].ItemSpec)); 978commandLine.AppendSwitchIfNotNull("/analyzer:", analyzer.ItemSpec); 991commandLine.AppendSwitchIfNotNull("/additionalfile:", additionalFile.ItemSpec); 1010commandLine.AppendSwitchIfNotNull("/embed:", embeddedFile.ItemSpec); 1024commandLine.AppendSwitchIfNotNull("/analyzerconfig:", analyzerConfigFile.ItemSpec); 1101item.ItemSpec = Utilities.GetFullPathNoThrow(item.ItemSpec); 1127var itemSpec = sources[i].ItemSpec; 1141transformedSources[j] = sources[j].ItemSpec; 1222if (!File.Exists(reference.ItemSpec)) 1225Log.LogErrorWithCodeFromResources("General_ReferenceDoesNotExist", reference.ItemSpec);

src\Compilers\Core\MSBuildTask\MapSourceRoots.cs (8)

106if (!EndsWithDirectorySeparator(sourceRoot.ItemSpec)) 108Log.LogErrorFromResources("MapSourceRoots.PathMustEndWithSlashOrBackslash", Names.SourceRoot, sourceRoot.ItemSpec); 112sourceRoot.ItemSpec = NormalizePath(sourceRoot.ItemSpec); 114if (rootByItemSpec.TryGetValue(sourceRoot.ItemSpec, out var existingRoot)) 121rootByItemSpec.Add(sourceRoot.ItemSpec, sourceRoot); 140string localPath = root.ItemSpec; 212root.SetMetadata(Names.MappedPath, root.ItemSpec); 236Log.LogWarningFromResources("MapSourceRoots.ContainsDuplicate", Names.SourceRoot, left.ItemSpec, metadataName, leftValue, rightValue);

src\Compilers\Core\MSBuildTask\Utilities.cs (1)

54item.ItemSpec, itemMetadataName, metadataValue, "bool");

src\Compilers\Core\MSBuildTask\Vbc.cs (3)

280MovePdbFileIfNecessary(OutputAssembly?.ItemSpec); 565commandLine.AppendSwitchIfNotNull("@", response.ItemSpec); 870CheckHostObjectSupport(param = nameof(OutputAssembly), vbcHostObject.SetOutputAssembly(OutputAssembly?.ItemSpec));

src\Compilers\Core\MSBuildTaskTests\TestUtilities\MSBuildUtil.cs (2)

25taskItem.Setup(x => x.ItemSpec).Returns(fileName); 32taskItem.Setup(x => x.ItemSpec).Returns(fileName);

MapSourceRootTests.cs (15)

TestUtilities\MSBuildUtil.cs (2)

25taskItem.Setup(x => x.ItemSpec).Returns(fileName); 32taskItem.Setup(x => x.ItemSpec).Returns(fileName);

TestUtilities\TaskTestUtil.cs (2)

26Assert.Equal(expected, task.GenerateCommandLineArgsTaskItems(rsp).Select(x => x.ItemSpec)); 39Assert.Equal(expected, compilerTask.CommandLineArgs!.Select(x => x.ItemSpec));

AddToWin32Manifest.cs (5)

93if (string.IsNullOrEmpty(ApplicationManifest.ItemSpec) || !FileSystems.Default.FileExists(ApplicationManifest?.ItemSpec)) 95Log.LogErrorWithCodeFromResources(null, ApplicationManifest?.ItemSpec, 0, 0, 0, 0, "AddToWin32Manifest.SpecifiedApplicationManifestCanNotBeFound"); 99return ApplicationManifest!.ItemSpec; 139SaveManifest(document, Path.GetFileName(ApplicationManifest?.ItemSpec) ?? DefaultManifestName);

Al.cs (1)

347commandLine.AppendSwitchIfNotNull("/out:", OutputAssembly?.ItemSpec);

AssemblyDependency\GenerateBindingRedirects.cs (5)

108var outputExists = FileSystems.Default.FileExists(OutputAppConfigFile.ItemSpec); 137Log.LogMessageFromResources(MessageImportance.Low, "GenerateBindingRedirects.CreatingBindingRedirectionFile", OutputAppConfigFile.ItemSpec); 138using (var stream = FileUtilities.OpenWrite(OutputAppConfigFile.ItemSpec, false)) 340using (XmlReader xr = XmlReader.Create(File.OpenRead(appConfigItem.ItemSpec), xrs)) 366var redirectStr = redirect.ItemSpec;

AssemblyDependency\Reference.cs (1)

152string itemSpec = sourceItem.ItemSpec;

AssemblyDependency\ReferenceTable.cs (15)

AssemblyDependency\ResolveAssemblyReference.cs (13)

1413log.AppendLine().Append(Strings.TwelveSpaces).Append(sourceItem.ItemSpec); 1518Log.LogMessage(importance, indent + item.ItemSpec); 1530Log.LogMessage(importance, indent + item.ItemSpec); 1924Log.LogMessage(importance, Strings.RequiredBy, dependee.ItemSpec); 2653if (fileExists(item.ItemSpec) && !Reference.IsFrameworkFile(item.ItemSpec, _targetFrameworkDirectories)) 2657assemblyName = getAssemblyName(item.ItemSpec); 2820Log.LogErrorWithCodeFromResources("ResolveAssemblyReference.FrameworkDirectoryOnProfiles", item.ItemSpec); 2889string fileName = subsetItems.ItemSpec; 3111tableMap[installedAssemblyTable.ItemSpec] = new AssemblyTableInfo(installedAssemblyTable.ItemSpec, frameworkDirectory); 3168Log.LogMessageFromResources(MessageImportance.Normal, "ResolveAssemblyReference.IgnoringBecauseNonEmptySubtype", assembly.ItemSpec, subType); 3172Log.LogWarningWithCodeFromResources("ResolveAssemblyReference.FailedToResolveReferenceBecauseHigherTargetFramework", assembly.ItemSpec, assembly.GetMetadata(ItemMetadataNames.targetFramework));

AssemblyDependency\TaskItemSpecFilenameComparer.cs (2)

55string xItemSpec = x.ItemSpec; 56string yItemSpec = y.ItemSpec;

AssignCulture.cs (4)

162AssignedFiles[i].ItemSpec, 174existingCulture, AssignedFiles[i].ItemSpec, info.culture); 202AssignedFiles[i].ItemSpec); 206Log.LogErrorWithCodeFromResources("AssignCulture.CannotExtractCulture", Files[i].ItemSpec, e.Message);

AssignProjectConfiguration.cs (2)

204Log.LogMessageFromResources(MessageImportance.Low, "AssignProjectConfiguration.ProjectConfigurationResolutionSuccess", projectRef.ItemSpec, resolvedReference.GetMetadata(attrFullConfiguration)); 235Log.LogMessageFromResources(MessageImportance.Low, "AssignProjectConfiguration.ProjectConfigurationUnresolved", projectRef.ItemSpec);

AssignTargetPath.cs (7)

113!Path.IsPathRooted(Files[i].ItemSpec) && 115!Files[i].ItemSpec.Contains("." + Path.DirectorySeparatorChar) && 122targetPath = Files[i].ItemSpec; 129TaskEnvironment.GetAbsolutePath(Files[i].ItemSpec).GetCanonicalForm(); 140targetPath = Path.GetFileName(Files[i].ItemSpec); 146Path.GetFullPath(TaskEnvironment.GetAbsolutePath(Files[i].ItemSpec)); 156targetPath = Path.GetFileName(Files[i].ItemSpec);

CombinePath.cs (1)

71combinedPath.ItemSpec = Path.Combine(BasePath, path.ItemSpec);

CombineTargetFrameworkInfoProperties.cs (1)

55root.Add(new XElement(item.ItemSpec, item.GetMetadata("Value")));

CombineXmlElements.cs (1)

41root.Add(XElement.Parse(item.ItemSpec));

CommandLineBuilderExtension.cs (1)

245AppendSwitchIfNotNull(switchName, parameter.ItemSpec);

ComReferenceInfo.cs (2)

204return taskItem.ItemSpec; 215internal string SourceItemSpec => taskItem?.ItemSpec;

ConvertToAbsolutePath.cs (1)

57if (!Path.IsPathRooted(path.ItemSpec))

Copy.cs (17)

507string sourceSpec = SourceFiles[i].ItemSpec; 508string destSpec = DestinationFiles[i].ItemSpec; 617string destPath = destItem.ItemSpec; 673string sourceSpec = sourceItem.ItemSpec; 674string destSpec = destItem.ItemSpec; 823() => Path.Combine(DestinationFolder.ItemSpec, Path.GetFileName(SourceFiles[i].ItemSpec)), 824SourceFiles[i].ItemSpec, 825DestinationFolder.ItemSpec, 849ErrorUtilities.VerifyThrowArgumentLength(sourceFolder.ItemSpec); 850AbsolutePath src = FileUtilities.NormalizePath(TaskEnvironment.GetAbsolutePath(sourceFolder.ItemSpec)); 863sourceFolder.ItemSpec, 864DestinationFolder.ItemSpec, 872() => Path.Combine(DestinationFolder.ItemSpec, srcName, file), 873sourceFolder.ItemSpec, 874DestinationFolder.ItemSpec, 1056if (DestinationFolder != null && FileSystems.Default.FileExists(TaskEnvironment.GetAbsolutePath(DestinationFolder.ItemSpec)))

CreateItem.cs (8)

109(!excludeItems.ContainsKey(i.ItemSpec))) 156if (FileMatcher.HasWildcards(i.ItemSpec)) 158FileMatcher.Default.GetFileSpecInfo(i.ItemSpec, out string directoryPart, out string wildcardPart, out string filenamePart, out bool needsRecursion, out bool isLegalFileSpec); 164EscapingUtilities.UnescapeAll(i.ItemSpec), 174EscapingUtilities.UnescapeAll(i.ItemSpec), 181(files, _, _, string? globFailure) = FileMatcher.Default.GetFiles(null /* use current directory */, i.ItemSpec); 192FileMatcher.Result match = FileMatcher.Default.FileMatch(i.ItemSpec, file); 225uniqueItems[item.ItemSpec] = String.Empty;

CreateManifestResourceName.cs (3)

158string fileName = resourceFile.ItemSpec; 222itemSpecToTaskitem[resourceFile.ItemSpec] = resourceFile; 257Log.LogErrorWithCodeFromResources("CreateManifestResourceName.Error", resourceFile.ItemSpec, e.Message);

Delete.cs (7)

123while (!deletedFilesSet.Contains(file.ItemSpec)) 128filePath = TaskEnvironment.GetAbsolutePath(file.ItemSpec); 152deletedFilesSet.Add(file.ItemSpec); 160Log.LogWarningWithCodeFromResources("Delete.Retrying", filePath?.OriginalValue ?? file.ItemSpec, retries, RetryDelayMilliseconds, e.Message, lockedFileMessage); 169Log.LogWarningWithCodeFromResources("Delete.Error", filePath?.OriginalValue ?? file.ItemSpec, e.Message, lockedFileMessage); 173Log.LogErrorWithCodeFromResources("Delete.Error", filePath?.OriginalValue ?? file.ItemSpec, e.Message, lockedFileMessage); 176deletedFilesSet.Add(file.ItemSpec);

DownloadFile.cs (3)

182AbsolutePath destinationFolderPath = TaskEnvironment.GetAbsolutePath(DestinationFolder.ItemSpec); 329filename = !string.IsNullOrWhiteSpace(DestinationFileName?.ItemSpec) 330? DestinationFileName.ItemSpec // Get the file name from what the user specified

FileIO\GetFileHash.cs (2)

91AbsolutePath filePath = TaskEnvironment.GetAbsolutePath(file.ItemSpec); 95Log.LogErrorWithCodeFromResources("FileHash.FileNotFound", file.ItemSpec);

FileIO\ReadLinesFromFile.cs (1)

45AbsolutePath filePath = TaskEnvironment.GetAbsolutePath(File.ItemSpec);

FileIO\WriteLinesToFile.cs (3)

74ErrorUtilities.VerifyThrowArgumentLength(File.ItemSpec); 75AbsolutePath filePath = FileUtilities.NormalizePath(TaskEnvironment.GetAbsolutePath(File.ItemSpec)); 84buffer.AppendLine(line.ItemSpec);

FindAppConfigFile.cs (5)

125string filename = (matchWholeItemSpec ? item.ItemSpec : Path.GetFileName(item.ItemSpec)); 134AppConfigFile.SetMetadata("OriginalItemSpec", item.ItemSpec); 138Log.LogMessageFromResources(MessageImportance.Low, "FindInList.Found", AppConfigFile.ItemSpec); 146Log.LogMessageFromResources(MessageImportance.Low, "FindInList.InvalidPath", item.ItemSpec, ex.Message);

FindInList.cs (2)

108var path = FileUtilities.FixFilePath(item.ItemSpec); 122Log.LogMessageFromResources(MessageImportance.Low, "FindInList.InvalidPath", item.ItemSpec, ex.Message);

FindInvalidProjectReferences.cs (1)

93string referenceIdentity = item.ItemSpec;

GenerateApplicationManifest.cs (11)

234name = Path.GetFileName(item.ItemSpec); 237if (!file.ImportComComponent(item.ItemSpec, manifest.OutputMessages, name)) 258Extension = item.ItemSpec, 272if (!String.IsNullOrEmpty(ConfigFile?.ItemSpec)) 277if (!String.IsNullOrEmpty(IconFile?.ItemSpec)) 282if (!String.IsNullOrEmpty(TrustInfoFile?.ItemSpec)) 285manifest.TrustInfo.Read(TrustInfoFile.ItemSpec); 445if (String.IsNullOrEmpty(InputManifest?.ItemSpec) || String.CompareOrdinal(InputManifest.ItemSpec, "NoManifest") == 0) 452using (Stream s = File.Open(InputManifest.ItemSpec, FileMode.Open, FileAccess.Read, FileShare.Read)) 479Log.LogErrorWithCodeFromResources("GenerateManifest.ReadInputManifestFailed", InputManifest.ItemSpec, ex.Message);

GenerateBootstrapper.cs (4)

115if (!items.ContainsKey(bootstrapperItem.ItemSpec)) 117items.Add(bootstrapperItem.ItemSpec, bootstrapperItem); 121Log.LogWarningWithCodeFromResources("GenerateBootstrapper.DuplicateItems", bootstrapperItem.ItemSpec); 136Log.LogWarningWithCodeFromResources("GenerateBootstrapper.ProductNotFound", bootstrapperItem.ItemSpec, bootstrapperBuilder.Path);

GenerateLauncher.cs (2)

68string entryPointFileName = Path.GetFileName(EntryPoint.ItemSpec); 102OutputEntryPoint = new TaskItem(Path.Combine(Path.GetDirectoryName(EntryPoint.ItemSpec), results.KeyFile));

GenerateManifestBase.cs (21)

88AssemblyIdentity = AssemblyIdentity.FromAssemblyName(item.ItemSpec), 121assembly = _manifest.AssemblyReferences.Add(item.ItemSpec); 126AssemblyIdentity identity = AssemblyIdentity.FromAssemblyName(item.ItemSpec); 134assembly = new AssemblyReference(item.ItemSpec); 152AssemblyReference assembly = _manifest.AssemblyReferences.Add(item.ItemSpec); 160FileReference file = _manifest.FileReferences.Add(item.ItemSpec); 338targetPath = BaseReference.GetDefaultTargetPath(item.ItemSpec); 373Log.LogWarningWithCodeFromResources("GenerateManifest.InvalidItemValue", "AssemblyType", item.ItemSpec); 377Log.LogWarningWithCodeFromResources("GenerateManifest.InvalidItemValue", "AssemblyType", item.ItemSpec); 404Log.LogWarningWithCodeFromResources("GenerateManifest.InvalidItemValue", "DependencyType", item.ItemSpec); 408Log.LogWarningWithCodeFromResources("GenerateManifest.InvalidItemValue", "DependencyType", item.ItemSpec); 418return OutputManifest.ItemSpec; 436if (String.IsNullOrEmpty(InputManifest?.ItemSpec)) 455_manifest = ManifestReader.ReadManifest(manifestType.Name, InputManifest.ItemSpec, true); 459Log.LogErrorWithCodeFromResources("GenerateManifest.ReadInputManifestFailed", InputManifest.ItemSpec, ex.Message); 485if (!String.IsNullOrEmpty(EntryPoint?.ItemSpec)) 593string manifestFileName = Path.GetFileName(OutputManifest.ItemSpec); 618ManifestWriter.WriteManifest(_manifest, OutputManifest.ItemSpec, TargetFrameworkVersion); 622string lockedFileMessage = LockCheck.GetLockedFileMessage(OutputManifest.ItemSpec); 623Log.LogErrorWithCodeFromResources("GenerateManifest.WriteOutputManifestFailed", OutputManifest.ItemSpec, ex.Message, lockedFileMessage); 629Util.WriteLog($"Total time to generate manifest '{Path.GetFileName(OutputManifest.ItemSpec)}': t={Environment.TickCount - _startTime}");

GenerateResource.cs (53)

582[inputFiles[i].ItemSpec, outputFiles[i].ItemSpec], 587commandLineBuilder.AppendFileNameIfNotNull(inputFiles[i].ItemSpec); 670if (item.ItemSpec.EndsWith(".dll", StringComparison.OrdinalIgnoreCase)) 672if (item.ItemSpec.EndsWith(".resources.dll", StringComparison.OrdinalIgnoreCase)) 761if (IsDangerous(source.ItemSpec)) 763Log.LogErrorWithCodeFromResources("GenerateResource.MOTW", source.ItemSpec); 1170if (!FileSystems.Default.FileExists(outputFile.ItemSpec)) 1172_unsuccessfullyCreatedOutFiles.Add(outputFile.ItemSpec); 1208if (!FileSystems.Default.FileExists(outputFile.ItemSpec)) 1210_unsuccessfullyCreatedOutFiles.Add(outputFile.ItemSpec); 1288_unsuccessfullyCreatedOutFiles.Add(outputFile.ItemSpec); 1389string sourceFileName = Sources[i].ItemSpec; 1405Sources[i].SetMetadata("OutputResource", OutputResources[i].ItemSpec); 1407if (!FileSystems.Default.FileExists(Sources[i].ItemSpec)) 1410Log.LogErrorWithCodeFromResources("GenerateResource.ResourceNotFound", Sources[i].ItemSpec); 1411_unsuccessfullyCreatedOutFiles.Add(OutputResources[i].ItemSpec); 1417if (ShouldRebuildResgenOutputFile(Sources[i].ItemSpec, OutputResources[i].ItemSpec)) 1432if (nothingOutOfDate && FileSystems.Default.FileExists(Sources[0].ItemSpec)) 1475Log.LogErrorWithCodeFromResources("GenerateResource.DuplicateOutputFilenames", item.ItemSpec); 1481Log.LogErrorWithCodeFromResources("GenerateResource.InvalidFilename", item.ItemSpec, e.Message); 1634StronglyTypedFileName = ProcessResourceFiles.GenerateDefaultStronglyTypedFilename(provider, OutputResources[0].ItemSpec); 1643_unsuccessfullyCreatedOutFiles.Add(OutputResources[0].ItemSpec); 1653DateTime sourceTime = NativeMethodsShared.GetLastWriteFileUtcTime(Sources[0].ItemSpec); 1660Log.LogMessageFromResources(MessageImportance.Low, "GenerateResource.InputDoesntExist", Sources[0].ItemSpec); 1672Log.LogMessageFromResources(MessageImportance.Low, "GenerateResource.InputNewer", Sources[0].ItemSpec, StronglyTypedFileName); 1712DateTime time = NativeMethodsShared.GetLastWriteFileUtcTime(input.ItemSpec); 1717_newestUncorrelatedInput = input.ItemSpec; 1726_newestUncorrelatedInput = input.ItemSpec; 1750string extension = Path.GetExtension(source.ItemSpec); 1769FileStream fs = File.OpenRead(source.ItemSpec); 1835source.ItemSpec, 1879source.ItemSpec, 1907source.ItemSpec, 1918source.ItemSpec, 1942source.ItemSpec, 2063OutputResources[i] = new TaskItem(Path.ChangeExtension(Sources[i].ItemSpec, ".resources")); 2068Log.LogErrorWithCodeFromResources("GenerateResource.InvalidFilename", Sources[i].ItemSpec, e.Message); 2112_unsuccessfullyCreatedOutFiles.Contains(OutputResources[i].ItemSpec)) 2143if (StateFile?.ItemSpec.Length > 0) 2162provider, OutputResources[0].ItemSpec); 2185_cache = ResGenDependencies.DeserializeCache(StateFile?.ItemSpec, UseSourcePath, Log); 2197_cache.SerializeCache(StateFile?.ItemSpec, Log); 2438string outputSpec = _extractResWFiles ? resWOutputDirectory : _outFiles[i].ItemSpec; 2439if (!ProcessFile(_inFiles[i].ItemSpec, outputSpec)) 2485return Assembly.UnsafeLoadFrom(_assemblyFiles[i].ItemSpec); 2502return Assembly.UnsafeLoadFrom(_assemblyFiles[i].ItemSpec); 2524if (assemblyFile.ItemSpec != null && FileSystems.Default.FileExists(assemblyFile.ItemSpec)) 2540_assemblyNames[i] = new AssemblyNameExtension(Path.GetFileNameWithoutExtension(assemblyFile.ItemSpec)); 3237ReadAssemblyResources(satelliteAssembly.ItemSpec, outFileOrDir); 4149Assembly a = this.GetAssemblyByPath(referencePath.ItemSpec, throwOnError);

GenerateTrustInfo.cs (4)

53if (BaseManifest != null && FileSystems.Default.FileExists(BaseManifest.ItemSpec)) 57trustInfo.ReadManifest(BaseManifest.ItemSpec); 61Log.LogErrorWithCodeFromResources("GenerateManifest.ReadInputManifestFailed", BaseManifest.ItemSpec, ex.Message); 102trustInfo.Write(TrustInfoFile.ItemSpec);

GetAssemblyIdentity.cs (3)

71an = AssemblyName.GetAssemblyName(item.ItemSpec); 75Log.LogErrorWithCodeFromResources("GetAssemblyIdentity.CouldNotGetAssemblyName", item.ItemSpec, e.Message); 80Log.LogErrorWithCodeFromResources("GetAssemblyIdentity.CouldNotGetAssemblyName", item.ItemSpec, e.Message);

GetCompatiblePlatform.cs (2)

65string? buildProjectReferenceAs = PlatformNegotiation.GetNearestPlatform(projectReferenceOverridePlatformNegotiationMetadata, referencedProjectPlatform, projectReferencePlatformsMetadata, projectReferenceLookupTableMetadata, PlatformLookupTable, AssignedProjectsWithPlatform[i].ItemSpec, CurrentProjectPlatform, Log); 68Log.LogMessageFromResources(MessageImportance.Low, "GetCompatiblePlatform.DisplayChosenPlatform", AssignedProjectsWithPlatform[i].ItemSpec, buildProjectReferenceAs);

GetSDKReferenceFiles.cs (21)

Hash.cs (2)

82string itemSpec = IgnoreCase ? ItemsToHash[i].ItemSpec.ToUpperInvariant() : ItemsToHash[i].ItemSpec;

InstalledSDKResolver.cs (1)

56string sdkDirectory = resolvedSDK.ItemSpec;

LC.cs (4)

146commandLine.AppendSwitchIfNotNull("/target:", LicenseTarget.ItemSpec); 150commandLine.AppendSwitchIfNotNull("/complist:", item.ItemSpec); 159commandLine.AppendSwitchIfNotNull("/i:", item.ItemSpec); 166string outputPath = LicenseTarget.ItemSpec + ".licenses";

ListOperators\FindUnderPath.cs (7)

70TaskEnvironment.GetAbsolutePath(FileUtilities.FixFilePath(Path.ItemSpec)).GetCanonicalForm()); 76System.IO.Path.GetFullPath(TaskEnvironment.GetAbsolutePath(FileUtilities.FixFilePath(Path.ItemSpec)))); 84"FindUnderPath.InvalidParameter", "Path", Path.ItemSpec, e.Message); 90Log.LogMessageFromResources(MessageImportance.Low, "FindUnderPath.ComparisonPath", Path.ItemSpec); 101TaskEnvironment.GetAbsolutePath(FileUtilities.FixFilePath(item.ItemSpec)).GetCanonicalForm()); 107System.IO.Path.GetFullPath(TaskEnvironment.GetAbsolutePath(FileUtilities.FixFilePath(item.ItemSpec)))); 113"FindUnderPath.InvalidParameter", "Files", item.ItemSpec, e.Message);

ListOperators\RemoveDuplicates.cs (1)

54if (alreadySeen.Add(item.ItemSpec))

MakeDir.cs (5)

58if (directory.ItemSpec.Length > 0) 64if (!directoriesSet.Contains(directory.ItemSpec)) 66absolutePath = TaskEnvironment.GetAbsolutePath(FileUtilities.FixFilePath(directory.ItemSpec)); 88Log.LogErrorWithCodeFromResources("MakeDir.Error", absolutePath?.OriginalValue ?? directory.ItemSpec, e.Message); 92directoriesSet.Add(directory.ItemSpec);

ManifestUtil\Util.cs (7)

415if (String.IsNullOrEmpty(item.ItemSpec)) 421var id = new AssemblyIdentity(item.ItemSpec); 428key = Path.GetFullPath(item.ItemSpec).ToUpperInvariant(); 606if (item1.ItemSpec == null || item2.ItemSpec == null) 611return String.Compare(item1.ItemSpec, item2.ItemSpec, StringComparison.Ordinal);

Move.cs (6)

136destinationFile = Path.Combine(DestinationFolder.ItemSpec, Path.GetFileName(SourceFiles[i].ItemSpec)); 140Log.LogErrorWithCodeFromResources("Move.Error", SourceFiles[i].ItemSpec, DestinationFolder.ItemSpec, e.Message, string.Empty); 158string sourceSpec = SourceFiles[i].ItemSpec; 159string destinationSpec = DestinationFiles[i].ItemSpec;

MSBuild.cs (9)

279string projectPath = FileUtilities.AttemptToShortenPath(project.ItemSpec); 315Log.LogErrorWithCodeFromResources("MSBuild.ProjectUpgradeNeededToVcxProj", project.ItemSpec); 351Log.LogMessageFromResources(MessageImportance.High, "MSBuild.ProjectFileNotFoundMessage", project.ItemSpec); 356Log.LogErrorWithCodeFromResources("MSBuild.ProjectFileNotFound", project.ItemSpec); 512string projectPath = FileUtilities.AttemptToShortenPath(projects[i].ItemSpec); 514projectNames[i] = projects[i].ItemSpec; 642outputItemFromTarget.ItemSpec = Path.Combine(projectDirectory[i], outputItemFromTarget.ItemSpec); 646log.LogWarningWithCodeFromResources(null, projects[i].ItemSpec, 0, 0, 0, 0, "MSBuild.CannotRebaseOutputItemPath", outputItemFromTarget.ItemSpec, e.Message);

RegisterAssembly.cs (8)

82if ((AssemblyListFile?.ItemSpec.Length > 0)) 84cacheFile = StateFileBase.DeserializeCache<AssemblyRegistrationCache>(AssemblyListFile.ItemSpec, Log) ?? 99if ((TypeLibFiles[i]?.ItemSpec.Length > 0)) 101tlbPath = TypeLibFiles[i].ItemSpec; 105tlbPath = Path.ChangeExtension(Assemblies[i].ItemSpec, ".tlb"); 111if (!Register(Assemblies[i].ItemSpec, tlbPath)) 117cacheFile?.AddEntry(Assemblies[i].ItemSpec, tlbPath); 138cacheFile?.SerializeCache(AssemblyListFile.ItemSpec, Log);

RemoveDir.cs (2)

60if (string.IsNullOrEmpty(directory.ItemSpec)) 68AbsolutePath directoryPath = TaskEnvironment.GetAbsolutePath(directory.ItemSpec);

RequiresFramework35SP1Assembly.cs (2)

159|| string.Equals(candidateFile.ItemSpec, Constants.NET35SP1AssemblyIdentity[0], StringComparison.OrdinalIgnoreCase) 160|| string.Equals(candidateFile.ItemSpec, Constants.NET35ClientAssemblyIdentity[0], StringComparison.OrdinalIgnoreCase)))

ResGen.cs (8)

260if (FileSystems.Default.FileExists(outputFiles[i].ItemSpec)) 277if (!FileSystems.Default.FileExists(outputFile.ItemSpec)) 286StronglyTypedClassName = Path.GetFileNameWithoutExtension(outputFile.ItemSpec); 296StronglyTypedFileName = ProcessResourceFiles.GenerateDefaultStronglyTypedFilename(provider, outputFile.ItemSpec); 488outputFiles[i] = new TaskItem(Path.ChangeExtension(EscapingUtilities.Escape(inputFiles[i].ItemSpec), ".resources")); 566resGenArguments.AppendTextUnquoted(reference.ItemSpec); 595resGenArguments.AppendTextUnquoted(inputFiles[i].ItemSpec); 597resGenArguments.AppendTextUnquoted(outputFiles[i].ItemSpec);

ResolveComReference.cs (21)

ResolveManifestFiles.cs (22)

177_runtimePackAssets = RuntimePackAssets.ToDictionary(p => p.ItemSpec, StringComparer.OrdinalIgnoreCase); 265ITaskItem outputItem = new TaskItem(item.ItemSpec); 288ITaskItem outputItem = new TaskItem(item.ItemSpec); 292targetPath = Path.GetFileName(item.ItemSpec); 329ITaskItem outputItem = new TaskItem(item.ItemSpec); 353string[] pathSegments = PathUtil.GetPathSegments(item.ItemSpec); 355Debug.Assert(!String.IsNullOrEmpty(itemCulture), $"Satellite item '{item.ItemSpec}' is missing expected attribute 'Culture'"); 370targetPath = Path.GetFileName(item.ItemSpec); 405AssemblyIdentity identity = AssemblyIdentity.FromManagedAssembly(item.ItemSpec); 511var outputAssembliesMap = outputAssemblies.ToDictionary(p => Path.GetFullPath(p.ItemSpec), StringComparer.OrdinalIgnoreCase); 523string key = Path.GetFullPath(item.ItemSpec); 585string fileExtension = Path.GetExtension(entry.item.ItemSpec); 673var outputEntryPoint = new TaskItem(entryPoint.ItemSpec); 736Log.LogWarningWithCodeFromResources("GenerateManifest.InvalidItemValue", "FileType", item.ItemSpec); 751_runtimePackAssets.TryGetValue(item.ItemSpec, out _)) 761AssemblyIdentity identity = AssemblyIdentity.FromManagedAssembly(item.ItemSpec); 762if (item.ItemSpec.EndsWith(".dll") && identity == null && !isDotNetCore) 810this.key = item.ItemSpec?.ToLowerInvariant(); 861fusionName = Path.Combine(destSubDir, Path.GetFileNameWithoutExtension(item.ItemSpec)); 865fusionName = Path.GetFileNameWithoutExtension(item.ItemSpec); 914AssemblyIdentity identity = AssemblyIdentity.FromManagedAssembly(item.ItemSpec); 925AssemblyIdentity identity = AssemblyIdentity.FromManagedAssembly(item.ItemSpec);

ResolveNativeReference.cs (6)

95return string.Compare(((ITaskItem)taskItem1).ItemSpec, ((ITaskItem)taskItem2).ItemSpec, StringComparison.OrdinalIgnoreCase); 126AssemblyIdentity ai = AssemblyIdentity.FromAssemblyName(item.ItemSpec); 129Log.LogMessageFromResources(MessageImportance.Low, "ResolveNativeReference.ResolveReference", item.ItemSpec); 139Log.LogMessageFromResources(MessageImportance.Low, "ResolveNativeReference.ResolveReference", item.ItemSpec); 167Log.LogWarningWithCodeFromResources("ResolveNativeReference.FailedToResolveReference", item.ItemSpec);

ResolveNonMSBuildProjectOutput.cs (7)

100Log.LogMessageFromResources(MessageImportance.Low, "ResolveNonMSBuildProjectOutput.ProjectReferenceResolutionStarting", projectRef.ItemSpec); 105if (resolvedPath.ItemSpec.Length > 0) 115GetAssemblyName(resolvedPath.ItemSpec); 124Log.LogMessageFromResources(MessageImportance.Low, "ResolveNonMSBuildProjectOutput.ProjectReferenceResolutionSuccess", projectRef.ItemSpec, resolvedPath.ItemSpec); 130Log.LogWarningWithCodeFromResources("ResolveNonMSBuildProjectOutput.ProjectReferenceResolutionFailure", projectRef.ItemSpec); 139Log.LogMessageFromResources(MessageImportance.Low, "ResolveNonMSBuildProjectOutput.ProjectReferenceUnresolved", projectRef.ItemSpec);

ResolveProjectBase.cs (2)

92Log.LogErrorWithCodeFromResources("General.MissingOrUnknownProjectReferenceAttribute", reference.ItemSpec, missingAttribute); 97Log.LogWarningWithCodeFromResources("General.MissingOrUnknownProjectReferenceAttribute", reference.ItemSpec, missingAttribute);

ResolveSDKReference.cs (8)

292if (ParseSDKReference(runtimeDependencyOnlyItem.ItemSpec, out string dependencyName, out string dependencyVersion)) 304string installLocation = installedsdk.ItemSpec; 564bool splitSuccessful = ParseSDKReference(referenceItem.ItemSpec, out string sdkSimpleName, out string rawSdkVersion); 568LogErrorOrWarning(new Tuple<string, object[]>("ResolveSDKReference.SDKReferenceIncorrectFormat", [referenceItem.ItemSpec])); 603Log.LogMessageFromResources(MessageImportance.Low, "ResolveSDKReference.SearchingForSDK", reference.ReferenceItem.ItemSpec); 620LogErrorOrWarning(new Tuple<string, object[]>("ResolveSDKReference.CouldNotResolveSDK", [reference.ReferenceItem.ItemSpec])); 919ResolvedPath = FileUtilities.EnsureTrailingSlash(sdk.ItemSpec); 1023AddResolutionErrorOrWarning("ResolveSDKReference.ErrorResolvingSDK", ReferenceItem.ItemSpec, ResourceUtilities.FormatResourceStringStripCodeAndKeyword("ResolveSDKReference.ErrorReadingManifest", _sdkManifestPath, _sdkManifest.ReadErrorMessage));

RoslynCodeTaskFactory\RoslynCodeTaskFactoryCompilers.cs (1)

109commandLine.AppendSwitchIfNotNull(ReferenceSwitch, reference.ItemSpec);

SignFile.cs (1)

57SigningTarget.ItemSpec,

TaskParameter.cs (1)

595_escapedItemSpec = EscapingUtilities.Escape(copyFrom.ItemSpec);

Touch.cs (2)

101path = TaskEnvironment.GetAbsolutePath(FileUtilities.FixFilePath(file.ItemSpec)); 105Log.LogErrorWithCodeFromResources("Touch.FileDoesNotExist", file.ItemSpec, ex.Message);

UnregisterAssembly.cs (8)

60cacheFile = StateFileBase.DeserializeCache<AssemblyRegistrationCache>(AssemblyListFile.ItemSpec, Log); 65StateFileBase.DeleteFile(AssemblyListFile.ItemSpec, Log); 89if (TypeLibFiles?[i]?.ItemSpec.Length > 0) 91cacheFile.AddEntry(Assemblies[i].ItemSpec, TypeLibFiles[i].ItemSpec); 95cacheFile.AddEntry(Assemblies[i].ItemSpec, Path.ChangeExtension(Assemblies[i].ItemSpec, ".tlb")); 137StateFileBase.DeleteFile(AssemblyListFile.ItemSpec, Log);

Unzip.cs (6)

94AbsolutePath destinationPath = TaskEnvironment.GetAbsolutePath(DestinationFolder.ItemSpec); 99Log.LogErrorWithCodeFromResources("Unzip.ErrorCouldNotCreateDestinationDirectory", DestinationFolder.ItemSpec, e.Message); 117sourceFilePath = TaskEnvironment.GetAbsolutePath(sourceFile.ItemSpec); 121Log.LogErrorWithCodeFromResources("Unzip.ErrorFileDoesNotExist", sourceFile.ItemSpec); 127Log.LogErrorWithCodeFromResources("Unzip.ErrorFileDoesNotExist", sourceFile.ItemSpec); 159Log.LogErrorWithCodeFromResources("Unzip.ErrorCouldNotOpenFile", sourceFile.ItemSpec, e.Message);

UpdateManifest.cs (3)

38Manifest.UpdateEntryPoint(InputManifest.ItemSpec, OutputManifest.ItemSpec, ApplicationPath, ApplicationManifest.ItemSpec, TargetFrameworkVersion);

WinMDExp.cs (1)

230commandLine.AppendSwitchUnquotedIfNotNull("/reference:", reference.ItemSpec);

WriteCodeFragment.cs (9)

113if (OutputFile != null && OutputDirectory != null && !Path.IsPathRooted(OutputFile.ItemSpec)) 115OutputFile = new TaskItem(Path.Combine(OutputDirectory.ItemSpec, OutputFile.ItemSpec)); 120outputFilePath = TaskEnvironment.GetAbsolutePath(OutputFile.ItemSpec); 124AbsolutePath outputDirectoryPath = TaskEnvironment.GetAbsolutePath(OutputDirectory.ItemSpec); 126OutputFile = new TaskItem(Path.Combine(OutputDirectory.ItemSpec, Path.GetFileName(outputFilePath.Value))); 135string itemSpec = OutputFile?.ItemSpec ?? String.Empty; 141Log.LogMessageFromResources(MessageImportance.Low, "WriteCodeFragment.GeneratedFile", OutputFile.ItemSpec); 273var attribute = new CodeAttributeDeclaration(new CodeTypeReference(attributeItem.ItemSpec));

XamlTaskFactory\CommandLineGenerator.cs (1)

354clb.AppendSwitchIfNotNull(commandLineToolSwitch.SwitchValue, itemName.ItemSpec);

XmlPeek.cs (2)

74AbsolutePath? absoluteInputPath = XmlInputPath != null ? TaskEnvironment.GetAbsolutePath(XmlInputPath.ItemSpec) : null; 94Log.LogErrorWithCodeFromResources("XmlPeekPoke.InputFileError", XmlInputPath.ItemSpec, e.Message);

XmlPoke.cs (5)

71inputPath = TaskEnvironment.GetAbsolutePath(XmlInputPath.ItemSpec); 83Log.LogErrorWithCodeFromResources("XmlPeekPoke.InputFileError", XmlInputPath.ItemSpec, e.Message); 133iter.Current.InnerXml = Value.ItemSpec; 134Log.LogMessageFromResources(MessageImportance.Low, "XmlPoke.Replaced", iter.Current.Name, Value.ItemSpec); 138Log.LogErrorWithCodeFromResources("XmlPoke.PokeError", Value.ItemSpec, e.Message);

XslTransformation.cs (6)

113? Array.ConvertAll(XmlInputPaths, item => item.ItemSpec != null ? TaskEnvironment.GetAbsolutePath(item.ItemSpec) : (AbsolutePath?)null) 117AbsolutePath? absoluteXslInputPath = XslInputPath?.ItemSpec != null ? TaskEnvironment.GetAbsolutePath(XslInputPath.ItemSpec) : null; 118xsltinput = new XsltInput(absoluteXslInputPath, XslContent, XslCompiledDllPath?.ItemSpec, TaskEnvironment, Log, PreserveWhitespace); 181using (XmlWriter xmlWriter = XmlWriter.Create(TaskEnvironment.GetAbsolutePath(_outputPaths[i].ItemSpec), xslct.OutputSettings))

ZipDirectory.cs (2)

66AbsolutePath sourceDirectoryAbsolutePath = TaskEnvironment.GetAbsolutePath(SourceDirectory.ItemSpec); 75AbsolutePath destinationFileAbsolutePath = TaskEnvironment.GetAbsolutePath(DestinationFile.ItemSpec);

Al_Tests.cs (1)

355Assert.Equal("foo.dll", t.OutputAssembly.ItemSpec); // "New value"

AssemblyDependency\AssemblyFoldersFromConfig_Tests.cs (4)

55Assert.Equal(Path.Combine(s_rootPathPrefix, "assemblyfromconfig", "folder2", "assemblyfromconfig2.dll"), t.ResolvedFiles[0].ItemSpec); 85Assert.Equal(Path.Combine(s_rootPathPrefix, "assemblyfromconfig", "folder_x86", "assemblyfromconfig_common.dll"), t.ResolvedFiles[0].ItemSpec); 115Assert.Equal(Path.Combine(s_rootPathPrefix, "assemblyfromconfig", "folder501000x86", "v5assembly.dll"), t.ResolvedFiles[0].ItemSpec); 130Assert.Equal(Path.Combine(s_rootPathPrefix, "assemblyfromconfig", "folder5010x64", "v5assembly.dll"), t.ResolvedFiles[0].ItemSpec);

AssemblyDependency\FilePrimary.cs (2)

455Assert.Equal(t.ResolvedFiles[0].ItemSpec, assemblyFiles[0].ItemSpec);

AssemblyDependency\InstalledSDKResolverFixture.cs (1)

96Assert.Equal(expectedPath, t.ResolvedFiles[0].ItemSpec, true);

AssemblyDependency\Miscellaneous.cs (93)

AssemblyDependency\Node\RarNodeExecuteRequest_Tests.cs (2)

41Assert.Equal(clientRar.Assemblies[i].ItemSpec, nodeRar.Assemblies[i].ItemSpec);

AssemblyDependency\Node\RarNodeExecuteResponse_Tests.cs (10)

52Assert.Equal(nodeRar.ResolvedFiles[i].ItemSpec, clientRar.ResolvedFiles[i].ItemSpec); 121Assert.Equal(nodeRar.CopyLocalFiles[i].ItemSpec, clientRar.CopyLocalFiles[i].ItemSpec); 127Assert.Equal(nodeRar.ResolvedFiles[i].ItemSpec, clientRar.ResolvedFiles[i].ItemSpec); 133Assert.Equal(nodeRar.ResolvedDependencyFiles[i].ItemSpec, clientRar.ResolvedDependencyFiles[i].ItemSpec); 139Assert.Equal(nodeRar.RelatedFiles[i].ItemSpec, clientRar.RelatedFiles[i].ItemSpec);

AssemblyDependency\ResolveAssemblyReferenceTestFixture.cs (4)

2956if (String.Equals(item.ItemSpec, spec, StringComparison.OrdinalIgnoreCase)) 3052Assert.Equal(loadModeResolvedFiles[i].ItemSpec, t.ResolvedFiles[i].ItemSpec); 3096Assert.Equal(cache, t.FilesWritten[0].ItemSpec);

AssemblyDependency\StronglyNamedDependencyAutoUnify.cs (7)

85t.ResolvedDependencyFiles[0].ItemSpec.ShouldBe(s_unifyMeDll_V20Path, StringCompareShould.IgnoreCase); 154Assert.Contains(Path.Combine(s_myApp_V10Path, "DependsOnUnified.dll"), t.ResolvedFiles[0].ItemSpec); // "Expected the ItemSpec of the resolved file to be the item spec of the 1.0.0.0 assembly"); 157t.ResolvedDependencyFiles[0].ItemSpec.ShouldBe(s_unifyMeDll_V10Path, StringCompareShould.IgnoreCase); 316engine.AssertLogContains(t.Log.FormatResourceString("ResolveAssemblyReference.FailBecauseDependentAssemblyInExclusionList", assemblyNames[0].ItemSpec, "UniFYme, Version=1.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089", stringList)); 317engine.AssertLogContains(t.Log.FormatResourceString("ResolveAssemblyReference.DependencyReferenceOutsideOfFramework", assemblyNames[1].ItemSpec, "UniFYme, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089", "2.0.0.0", "1.0.0.0")); 389t.ResolvedDependencyFiles[0].ItemSpec.ShouldBe(s_unifyMeDll_V20Path, StringCompareShould.IgnoreCase); 443t.ResolvedDependencyFiles[0].ItemSpec.ShouldBe(s_unifyMeDll_V30Path, StringCompareShould.IgnoreCase);

AssemblyDependency\VerifyTargetFrameworkHigherThanRedist.cs (1)

95Assert.Equal(Path.Combine(s_myComponentsMiscPath, "ReferenceVersion9.dll"), t.ResolvedFiles[0].ItemSpec);

AssemblyDependency\WinMDTests.cs (15)

AssignCulture_Tests.cs (26)

AssignLinkMetadata_Tests.cs (4)

76Assert.Equal(item.ItemSpec, t.OutputItems[0].ItemSpec); 103Assert.Equal(item2.ItemSpec, t.OutputItems[0].ItemSpec);

AssignProjectConfiguration_Tests.cs (3)

59Assert.Equal(reference.ItemSpec, resolvedProjectWithConfiguration.ItemSpec); 279unresolvedProjects[rpc.UnassignedProjects[i].ItemSpec] = rpc.UnassignedProjects[i];

AssignTargetPath_Tests.cs (1)

29t.AssignedFiles[0].ItemSpec.ShouldBe(NativeMethodsShared.IsWindows ? @"c:\bin2\abc.efg" : "/bin2/abc.efg");

ConvertToAbsolutePath_Tests.cs (3)

44Assert.EndsWith(testFile.FullName, t.AbsolutePaths[0].ItemSpec); 76Assert.EndsWith(testFile.FullName, t.AbsolutePaths[0].ItemSpec); 106Assert.Equal(testFile.FullName, t.AbsolutePaths[0].ItemSpec);

Copy_Tests.cs (26)

CreateCSharpManifestResourceName_Tests.cs (12)

375Assert.Equal(@"CustomToolTest.SR1", resourceNames[0].ItemSpec); 404t.ManifestResourceNames[0].ItemSpec.ShouldBe("MyStuff.Namespace.Class", "Expecting to find the namespace & class name from SR1.cs"); 444t.ManifestResourceNames[0].ItemSpec.ShouldBe(ResourceFileName, "Expecting to find the namespace & class name from SR1.cs"); 477t.ManifestResourceNames[0].ItemSpec.ShouldBe("MyStuff.Namespace.Class", "Expecting to find the namespace & class name from SR1.cs"); 511t.ManifestResourceNames[0].ItemSpec.ShouldBe("SR1", "Expected only the file name."); 542t.ManifestResourceNames[0].ItemSpec.ShouldBe("MyStuff2.Namespace.Class2", "Expected the namespace & class of SR2."); 576t.ManifestResourceNames[0].ItemSpec.ShouldBe("SR1", "Expected only the file name."); 613t.ManifestResourceNames[0].ItemSpec.ShouldBe("MyStuff.Namespace.Class.de", "Expected Namespace.Class.Culture"); 808Assert.Equal(@"strings.resx", resourceFiles[0].ItemSpec); 834Assert.Equal(@"pic.bmp", resourceFiles[0].ItemSpec); 860Assert.Equal(@"pic.bmp", resourceFiles[0].ItemSpec); 885Assert.Equal(@"strings.resx", resourceFiles[0].ItemSpec);

CreateItem_Tests.cs (3)

79Assert.Equal("MyFile.txt", t.Include[0].ItemSpec); 97Assert.Equal(t.Include[0].ItemSpec, t.Include[0].ItemSpec);

CreateVisualBasicManifestResourceName_Tests.cs (6)

363Assert.Equal(@"CustomToolTest.SR1", resourceNames[0].ItemSpec); 403t.ManifestResourceNames[0].ItemSpec.ShouldBe("MyStuff.Class2.de", "Expected Namespace.Class.Culture"); 528Assert.Equal(@"strings.resx", resourceFiles[0].ItemSpec); 554Assert.Equal(@"pic.bmp", resourceFiles[0].ItemSpec); 580Assert.Equal(@"pic.bmp", resourceFiles[0].ItemSpec); 605Assert.Equal(@"strings.resx", resourceFiles[0].ItemSpec);

Delete_Tests.cs (1)

39Assert.Equal("MyFiles.nonexistent", t.DeletedFiles[0].ItemSpec);

DownloadFile_Tests.cs (3)

85downloadFile.DownloadedFile.ItemSpec.ShouldBe(file.FullName); 131downloadFile.DownloadedFile.ItemSpec.ShouldBe(file.FullName); 166downloadFile.DownloadedFile.ItemSpec.ShouldBe(file.FullName);

Exec_Tests.cs (1)

1069exec.ConsoleOutput[0].ItemSpec.ShouldBe(lineWithLeadingWhitespace);

FindAppConfigFile_Tests.cs (5)

25Assert.Equal("app.config", f.AppConfigFile.ItemSpec); 38Assert.Equal("app.config", f.AppConfigFile.ItemSpec); 51Assert.Equal(FileUtilities.FixFilePath("foo\\app.config"), f.AppConfigFile.ItemSpec); 77Assert.Equal(FileUtilities.FixFilePath(@"foo\\app.config"), f.AppConfigFile.ItemSpec); 94Assert.Equal("app.config", f.AppConfigFile.ItemSpec);

FindInList_Tests.cs (6)

25Assert.Equal("A.CS", f.ItemFound.ItemSpec); 37Assert.Equal("a.cs", f.ItemFound.ItemSpec); 64Assert.Equal("a.cs", f.ItemFound.ItemSpec); 84Assert.Equal("a.cs", f.ItemFound.ItemSpec); 120Assert.Equal(FileUtilities.FixFilePath(@"c:\foo\a.cs"), f.ItemFound.ItemSpec); 135Assert.Equal(FileUtilities.FixFilePath(@"foo\a.cs"), f.ItemFound.ItemSpec);

FindInvalidProjectReferences_Tests.cs (2)

58Assert.Equal("proj3.proj", t.InvalidReferences[0].ItemSpec); 59Assert.Equal("proj4.proj", t.InvalidReferences[1].ItemSpec);

FindUnderPath_Tests.cs (6)

36Assert.Equal(FileUtilities.FixFilePath(@"C:\MyProject\File1.txt"), t.InPath[0].ItemSpec); 37Assert.Equal(FileUtilities.FixFilePath(@"C:\SomeoneElsesProject\File2.txt"), t.OutOfPath[0].ItemSpec); 139Assert.Equal(testFile.FullName, t.InPath[0].ItemSpec); 141t.OutOfPath[0].ItemSpec); 162Assert.Equal(testFile.Name, t.InPath[0].ItemSpec); 164t.OutOfPath[0].ItemSpec);

GetAssembliesMetadata_Tests.cs (2)

44t.AssembliesMetadata[0].ItemSpec.ShouldBe(assemblyPath); 71t.AssembliesMetadata[0].ItemSpec.ShouldBe(assemblyPath);

GetInstalledSDKLocations_Tests.cs (2)

338extensionSDKs.Add(item.GetMetadata("SDKName"), item.ItemSpec); 412extensionSDKs.Add(item.GetMetadata("SDKName"), item.ItemSpec);

GetSDKReference_Tests.cs (94)

MakeDir_Tests.cs (8)

44Assert.Equal(dir, t.DirectoriesCreated[0].ItemSpec); 51Assert.Equal(dir, t.DirectoriesCreated[0].ItemSpec); 96Assert.Equal(dir2, t.DirectoriesCreated[1].ItemSpec); 104Assert.Equal(dir2, t.DirectoriesCreated[2].ItemSpec); 107Assert.Equal(dir, t.DirectoriesCreated[0].ItemSpec); 149Assert.Equal(dir, t.DirectoriesCreated[0].ItemSpec); 160Assert.Equal(dir, t.DirectoriesCreated[0].ItemSpec); 219Assert.Equal(dir, t.DirectoriesCreated[0].ItemSpec);

Move_Tests.cs (13)

MSBuild_Tests.cs (5)

1348Assert.Equal("|a", msbuildTask.TargetOutputs[0].ItemSpec); 1349Assert.Equal("A|b", msbuildTask.TargetOutputs[1].ItemSpec); 1350Assert.Equal("B|c", msbuildTask.TargetOutputs[2].ItemSpec); 1351Assert.Equal("C|d", msbuildTask.TargetOutputs[3].ItemSpec); 1352Assert.Equal("D|", msbuildTask.TargetOutputs[4].ItemSpec);

ReadLinesFromFile_Tests.cs (12)

49Assert.Equal("Line1", r.Lines[0].ItemSpec); 58Assert.Equal("Line1", r.Lines[0].ItemSpec); 59Assert.Equal("Line2", r.Lines[1].ItemSpec); 60Assert.Equal("Line3", r.Lines[2].ItemSpec); 98Assert.Equal("Line1_%3b_", r.Lines[0].ItemSpec); 107Assert.Equal("Line1_%3b_", r.Lines[0].ItemSpec); 108Assert.Equal("Line2", r.Lines[1].ItemSpec); 109Assert.Equal("Line3", r.Lines[2].ItemSpec); 145Assert.Equal("My special character is \u00C3", r.Lines[0].ItemSpec); 208Assert.Equal("Line1", r.Lines[0].ItemSpec); 209Assert.Equal("Line2", r.Lines[1].ItemSpec); 210Assert.Equal("Line3", r.Lines[2].ItemSpec);

RemoveDir_Tests.cs (2)

44t.RemovedDirectories[0].ItemSpec.ShouldBe("MyNonExistentDirectory"); 45Directory.Exists(t.RemovedDirectories[0].ItemSpec).ShouldBeFalse();

RemoveDuplicates_Tests.cs (11)

ResolveComReference_Tests.cs (2)

435Assert.Equal(newTlbInfo.taskItem.ItemSpec, axRefInfo.taskItem.ItemSpec); // "The added reference should have the same task item spec as the Ax reference"

ResolveNonMSBuildProjectOutput_Tests.cs (3)

119Assert.Equal(resolvedPath.ItemSpec, expectedPath); 200unresolvedOutputs[rvpo.UnresolvedProjectReferences[i].ItemSpec] = rvpo.UnresolvedProjectReferences[i]; 206resolvedOutputs[rvpo.ResolvedOutputPaths[i].ItemSpec] = rvpo.ResolvedOutputPaths[i];

ResolveSDKReference_Tests.cs (64)

ResourceHandling\GenerateResource_Tests.cs (301)

ResourceHandling\GenerateResourceOutOfProc_Tests.cs (233)

ResourceHandling\ResGen_Tests.cs (14)

48string commandLineParameter = String.Join(",", new string[] { singleTestFile[0].ItemSpec, singleOutput[0].ItemSpec }); 56CommandLine.ValidateHasParameter(t, singleTestFile[0].ItemSpec, false /* resgen 4.0 does not appear to support response files for STR */); 57CommandLine.ValidateHasParameter(t, singleOutput[0].ItemSpec, false /* resgen 4.0 does not appear to support response files for STR */); 70commandLineParameter = String.Join(",", new string[] { multipleTestFiles[i].ItemSpec, multipleOutputs[i].ItemSpec }); 131string commandLineParameter = String.Join(",", new string[] { differentLengthInput[0].ItemSpec, differentLengthDefaultOutput[0].ItemSpec }); 146commandLineParameter = String.Join(",", new string[] { inputFiles[0].ItemSpec, defaultOutput[0].ItemSpec }); 155commandLineParameter = String.Join(",", new string[] { inputFiles[0].ItemSpec, explicitOutput[0].ItemSpec }); 206CommandLine.ValidateHasParameter(t, "/r:" + singleReference[0].ItemSpec, true /* resgen 4.0 supports response files */); 214CommandLine.ValidateHasParameter(t, "/r:" + reference.ItemSpec, true /* resgen 4.0 supports response files */);

WriteCodeFragment_Tests.cs (42)

WriteLinesToFile_Tests.cs (5)

49Assert.False(File.Exists(a.File.ItemSpec)); 78Assert.Equal("\uBDEA", r.Lines[0].ItemSpec); 101Assert.NotEqual("\uBDEA", r.Lines[0].ItemSpec); 131r.Lines[0].ItemSpec.ShouldBe("File contents1"); 218r.Lines[0].ItemSpec.ShouldBe("File contents1");

XmlPeek_Tests.cs (7)

81Assert.Equal(p.Result[i].ItemSpec, results[i]); 110Assert.Equal(p.Result[i].ItemSpec, results[i]); 139Assert.Equal(p.Result[i].ItemSpec, results[i]); 161Assert.Equal(p.Result[i].ItemSpec, results[i]); 181Assert.Equal(p.Result[i].ItemSpec, results[i]); 198Assert.Equal(xmlInputPath, p.XmlInputPath.ItemSpec); 358Assert.Equal(["abcdefg", "a$(d)fg", "a$(d.f)"], p.Result.Select(x => x.ItemSpec));

XslTransformation_Tests.cs (4)

377using (StreamReader sr = new StreamReader(t.OutputPaths[0].ItemSpec)) 414using (StreamReader sr = new StreamReader(t.OutputPaths[0].ItemSpec)) 532Assert.Equal(xslCompiledPath.ItemSpec, t.XslCompiledDllPath.ItemSpec); 889using (StreamReader sr = new StreamReader(t.OutputPaths[0].ItemSpec))

ObjectModelHelpers.cs (7)

363expectedItemSpecs.Append(expectedItem.ItemSpec); 375actualItemSpecs.Append(actualItem.ItemSpec); 390if (expectedItems[expectedItemIndex].ItemSpec == actualItem.ItemSpec) 420string.Format("Item '{0}' does not have expected metadata '{1}'.", actualItem.ItemSpec, metadataName)); 424string.Format("Item '{0}' has unexpected metadata {1}={2}.", actualItem.ItemSpec, metadataName, actualMetadataValue)); 444Assert.Fail(string.Format("Item '{0}' was expected but not returned.", expectedItem.ItemSpec));

CommandLineBuilder.cs (8)

390VerifyThrowNoEmbeddedDoubleQuotes(string.Empty, fileItem.ItemSpec); 392AppendFileNameIfNotNull(fileItem.ItemSpec); 452VerifyThrowNoEmbeddedDoubleQuotes(string.Empty, fileItems[i].ItemSpec); 466AppendFileNameWithQuoting(fileItems[i].ItemSpec); 556AppendSwitchIfNotNull(switchName, parameter.ItemSpec); 622AppendTextWithQuoting(parameter.ItemSpec); 668AppendSwitchUnquotedIfNotNull(switchName, parameter.ItemSpec); 732AppendTextUnquoted(parameter.ItemSpec);

TaskItem.cs (1)

155_itemSpec = EscapingUtilities.Escape(sourceItem.ItemSpec);

TrackedDependencies\TrackedDependencies.cs (5)

36if (FileMatcher.HasWildcards(item.ItemSpec)) 39string? directoryName = Path.GetDirectoryName(item.ItemSpec); 40string searchPattern = Path.GetFileName(item.ItemSpec); 51(files, _, _, string? globFailure) = FileMatcher.Default.GetFiles(null, item.ItemSpec); 84if (!FileUtilities.FileExistsNoThrow(item.ItemSpec))

MSBuild\ProjectFile\CommandLineArgumentReader.cs (3)

122Add("additionalfile", Project.GetAbsolutePath(additionalFile.ItemSpec)); 134Add("analyzer", Project.GetAbsolutePath(analyzer.ItemSpec)); 209var trimmed = item.ItemSpec.Trim();

MSBuild\ProjectFile\ProjectInstanceReader.cs (5)

167.SelectAsArray(item => item.ItemSpec); 182=> !Path.GetFileName(item.ItemSpec).StartsWith("TemporaryGeneratedFile_", StringComparison.Ordinal); 213var filePath = documentItem.ItemSpec; 234=> GetAbsolutePathRelativeToProject(documentItem.ItemSpec); 249var filePath = documentItem.ItemSpec;

src\DownloadFile.cs (2)

81var uri = uriConfig.ItemSpec; 102Log.LogError($"Download from all targets failed. List of attempted targets: {string.Join(", ", Uris.Select(m => m.ItemSpec))}");

src\GenerateChecksums.cs (5)

30Log.LogError($"Metadata 'DestinationPath' is missing for item '{item.ItemSpec}'."); 34if (!File.Exists(item.ItemSpec)) 36Log.LogError($"The file '{item.ItemSpec}' does not exist."); 40Log.LogMessage(MessageImportance.High, $"Generating checksum for '{item.ItemSpec}' into '{destinationPath}'..."); 42using (FileStream stream = File.OpenRead(item.ItemSpec))

src\GenerateSourcePackageSourceLinkTargetsFile.cs (1)

50var itemSpec = sourceRoot.ItemSpec;

src\GetAssemblyFullName.cs (1)

29var assemblyPath = string.IsNullOrEmpty(PathMetadata) ? item.ItemSpec : item.GetMetadata(PathMetadata);

src\GroupItemsBy.cs (1)

77group item by item.ItemSpec

src\SaveItems.cs (1)

42project.AddItem(ItemName, item.ItemSpec, metadataPairs);

GroupItemsByTests.cs (1)

38}, task.GroupedItems.Select(i => $"{i.ItemSpec}: {string.Join(" ", inspectMetadata.Select(m => $"{m}='{i.GetMetadata(m)}'"))}"));

CreateUpdatePR.cs (1)

108UpdatedFiles.Select(file => file.ItemSpec).ToList(),

BlobArtifactModelFactory.cs (2)

38_log.LogError($"Missing 'RelativeBlobPath' property on blob {item.ItemSpec}"); 46OriginalFile = item.ItemSpec

BuildModelFactory.cs (1)

95_log.LogError($"Missing 'Kind' property on artifact {item.ItemSpec}. Possible values are 'Blob', 'PDB', 'Package'.");

PackageArtifactModelFactory.cs (3)

29_log.LogMessage($"Creating NupkgInfo based on '{item.ItemSpec}'"); 31NupkgInfo info = _nupkgInfoFactory.CreateNupkgInfo(item.ItemSpec); 39OriginalFile = item.ItemSpec

PdbArtifactModelFactory.cs (2)

36_log.LogError($"Missing 'RelativePdbPath' property on pdb {item.ItemSpec}"); 44OriginalFile = item.ItemSpec

src\BlobFeedAction.cs (5)

82string fileName = Path.GetFileName(item.ItemSpec); 94$"Item '{item.ItemSpec}' RelativeBlobPath contains virtual directory " + 114if (!await blobUtils.IsFileIdenticalToBlobAsync(item.ItemSpec, relativeBlobPath)) 129new FileStream(item.ItemSpec, FileMode.Open, FileAccess.Read, FileShare.Read)) 132await blobUtils.UploadBlockBlobAsync(item.ItemSpec, relativeBlobPath, stream);

src\common\UploadToAzure.cs (5)

94throw new Exception(string.Format("Metadata 'RelativeBlobPath' is missing for item '{0}'.", item.ItemSpec)); 97if (!File.Exists(item.ItemSpec)) 99throw new Exception(string.Format("The file '{0}' does not exist.", item.ItemSpec)); 108if (await blobReference.IsFileIdenticalToBlobAsync(item.ItemSpec)) 119using (Stream localFileStream = File.OpenRead(item.ItemSpec))

src\ConfigureInputFeed.cs (1)

38nugetConfigBody += $"<add key=\"inputFeed{i}\" value=\"{ EnableFeeds[i].ItemSpec }\" />{Environment.NewLine}";

src\model\SetupTargetFeedConfigV3.cs (2)

74FeedKeys = feedKeys.ToImmutableDictionary(i => i.ItemSpec, i => i.GetMetadata("Key")); 75FeedOverrides = feedOverrides.ToImmutableDictionary(i => i.ItemSpec, i => i.GetMetadata("Replacement"));

src\model\SetupTargetFeedConfigV4.cs (2)

73FeedKeys = feedKeys.ToImmutableDictionary(i => i.ItemSpec, i => i.GetMetadata("Key")); 74FeedOverrides = feedOverrides.ToImmutableDictionary(i => i.ItemSpec, i => i.GetMetadata("Replacement"));

src\PublishArtifactsInManifest.cs (1)

296.Select(manifestParam => WhichPublishingTask(manifestParam.ItemSpec))

src\PushToBuildStorage.cs (2)

504if (Enum.TryParse(item.ItemSpec, true, out ArtifactVisibility parsedVisibility)) 510throw new ArgumentException($"Invalid visibility: {item.ItemSpec}");

src\CreateControlFile.cs (2)

55string dependencyItem = depend.ItemSpec; 74writer.WriteLine($"{property.ItemSpec}: {property.GetMetadata("Value")}");

src\CreateDebPackage.cs (2)

36using Stream controlFile = File.OpenRead(ControlFile.ItemSpec); 38using Stream dataFile = File.OpenRead(DataFile.ItemSpec);

src\CreateLightCommandPackageDrop.cs (1)

74commandString.Append($" -sice:{siceItem.ItemSpec}");

src\CreateMD5SumsFile.cs (2)

38using FileStream fileStream = File.OpenRead(file.ItemSpec); 41string relativePath = file.ItemSpec.Substring(RootDirectory.Length).TrimStart(Path.DirectorySeparatorChar).Replace('\\', '/');

src\CreateRpmPackage.cs (6)

94builder.AddRequiredCapability(require.ItemSpec, require.GetMetadata("Version")); 99builder.AddConflict(conflict.ItemSpec); 104builder.AddChangelogLine(Packager, changelogLine.ItemSpec); 110HashSet<string> ownedDirectories = new(OwnedDirectories.Select(d => d.ItemSpec)); 114builder.AddScript(script.GetMetadata("Kind"), File.ReadAllText(script.ItemSpec)); 119Dictionary<string, string> filePathToKind = RawPayloadFileKinds.Select(k => k.ItemSpec.Split(':')).ToDictionary(k => k[0], k => k[1].Trim());

src\CreateWixBuildWixpack.cs (19)

src\CreateWixCommandPackageDropBase.cs (9)

106commandString.Append($" -loc {Path.GetFileName(locItem.ItemSpec)}"); 113commandString.Append($" -ext {wixExtension.ItemSpec}"); 120commandString.Append($" {Path.GetFileName(wixSrcFile.ItemSpec)}"); 144string newWixSrcFilePath = Path.Combine(packageDropOutputFolder, Path.GetFileName(wixSrcFile.ItemSpec)); 145File.Copy(wixSrcFile.ItemSpec, newWixSrcFilePath, true); 147string wixSrcFileExtension = Path.GetExtension(wixSrcFile.ItemSpec); 176var destinationPath = Path.Combine(packageDropOutputFolder, Path.GetFileName(locItem.ItemSpec)); 177File.Copy(locItem.ItemSpec, destinationPath, true); 292var possiblePath = Path.Combine(additionalBasePath.ItemSpec, oldPath);

src\StabilizeWixFileId.cs (4)

63Log.LogError($"{nameof(FileElementToStabilize)} {file.ItemSpec} has null/empty ReplacementId metadata."); 73?.EndsWith(file.ItemSpec, StringComparison.OrdinalIgnoreCase) == true) 79$"Expected 1 match for '{file.ItemSpec}', found {matchingFileElements.Length}: " + 94$"Setting '{file.ItemSpec}' Id to '{replacement}' for File with Source " +

ApplyBaseLine.cs (4)

65if (!baseLineVersions.TryGetValue(baseLinePackage.ItemSpec, out versions)) 67baseLineVersions[baseLinePackage.ItemSpec] = versions = new SortedSet<Version>(); 82if (baseLineVersions.TryGetValue(dependency.ItemSpec, out dependencyBaseLineVersions)) 112string packageId = dependency.ItemSpec;

ApplyMetaPackages.cs (3)

64if (!suppressMetaPackages.TryGetValue(metapackage.ItemSpec, out var value)) 67suppressMetaPackages.Add(metapackage.ItemSpec, value); 99var metaPackage = index?.MetaPackages?.GetMetaPackageId(originalDependency.ItemSpec);

ApplyPreReleaseSuffix.cs (2)

77string packageId = originalPackage.ItemSpec; 122string stablePackageId = stablePackage.ItemSpec;

CreateTrimDependencyGroups.cs (1)

182public TaskItemPackageDependency(ITaskItem item) : base(item.ItemSpec, TryParseVersionRange(item.GetMetadata("Version")))

FilterUnknownPackages.cs (3)

46var baseLinePackageIds = new HashSet<string>(BaseLinePackages.NullAsEmpty().Select(b => b.ItemSpec)); 52!dependency.ItemSpec.StartsWith("System.Private") || // only apply filtering to System.Private dependencies 53isKnownPackage(dependency.ItemSpec)

GenerateNuSpec.cs (4)

274orderby fr.ItemSpec, StringComparer.Ordinal 275select new FrameworkAssemblyReference(fr.ItemSpec, new[] { fr.GetTargetFramework() }) 301Id = d.ItemSpec, 335File = r.ItemSpec,

GeneratePackageReport.cs (4)

208fx = FrameworkUtilities.ParseNormalized(framework.ItemSpec); 212Log.LogError($"Could not parse Framework {framework.ItemSpec}. {ex}"); 218Log.LogError($"Did not recognize {framework.ItemSpec} as valid Framework."); 312Log.LogError($"Could not parse File {file.ItemSpec}. {ex}");

GenerateRuntimeDependencies.cs (9)

85Log.LogMessage(LogImportance.Low, "Aliasing {0} -> {1}", alias, dependency.ItemSpec); 86packageAliases[alias] = dependency.ItemSpec; 98Log.LogMessage(LogImportance.Low, "Skipping dependencies {0} since they don't have a TargetRuntime.", String.Join(", ", runtimeGroup.Select(d => d.ItemSpec))); 102if (runtimeGroup.Any(d => d.ItemSpec == c_emptyDependency)) 115var dependencyGroups = targetPackageGroup.GroupBy(d => d.ItemSpec); 156Log.LogWarning("Dependency {0} specified TargetPackageAlias {1} but no package was found defining this alias.", dependency.ItemSpec, targetPackageAlias); 165Log.LogMessage(LogImportance.Low, "Dependency {0} has no parent so will assume {1}.", dependency.ItemSpec, PackageId); 179Log.LogWarning("Dependency {0} has no version", dependency.ItemSpec); 184Log.LogError("Dependency {0} has invalid version {1}", dependency.ItemSpec, dependencyVersionString);

GetApplicableAssetsFromPackages.cs (4)

108Log.LogMessage($"Resolved compile assets from {compileFx.ToString()}: {String.Join(";", CompileAssets.Select(c => c.ItemSpec))}"); 132Log.LogMessage($"Resolved runtime assets from {runtimeFx.ToString()}: {String.Join(";", RuntimeAssets.Select(r => r.ItemSpec))}"); 169Log.LogError($"Could not parse File {file.ItemSpec}. {ex}"); 210var pdbItem = new TaskItem(Path.ChangeExtension(packageItem.OriginalItem.ItemSpec, ".pdb"));

GetAssemblyReferences.cs (3)

50if (!File.Exists(assemblyItem.ItemSpec)) 52Log.LogError($"File {assemblyItem.ItemSpec} does not exist, ensure you have built libraries before building the package."); 56using (PEReader peReader = new PEReader(new FileStream(assemblyItem.ItemSpec, FileMode.Open, FileAccess.Read, FileShare.Delete | FileShare.Read)))

GetLastStablePackage.cs (3)

80var packageId = latestPackage.ItemSpec; 95var packageId = stablePackage.ItemSpec; 136var packageId = latestPackage.ItemSpec;

GetLayoutFiles.cs (1)

46i => NuGetFramework.Parse(i.ItemSpec),

GetMinimumNETStandard.cs (1)

31var minNETStandard = Frameworks.Select(fx => NuGetFramework.Parse(fx.ItemSpec))

GetPackageDestination.cs (2)

83var packageTargetFrameworks = PackageTargetFrameworks.NullAsEmpty().Where(p => !String.IsNullOrEmpty(p.ItemSpec)); 86var packageFx = NuGetFramework.Parse(packageTargetFramework.ItemSpec);

GetPackageFromModule.cs (2)

54modulesToPackages.Add(modulePackage.ItemSpec, modulePackage.GetMetadata("Package")); 62string moduleName = moduleReferenced.ItemSpec;

HarvestPackage.cs (7)

149_packageFolders.Add(runtimePackage.ItemSpec, LocatePackageFolder(runtimePackage.ItemSpec, runtimePackage.GetMetadata("Version"))); 184fx = FrameworkUtilities.ParseNormalized(framework.ItemSpec); 188Log.LogError($"Could not parse Framework {framework.ItemSpec}. {ex}"); 194Log.LogError($"Did not recognize {framework.ItemSpec} as valid Framework."); 233var supportedFramework = new TaskItem(framework.ItemSpec); 522_pathsToInclude = PathsToInclude.NullAsEmpty().ToDictionary(i => NormalizePath(i.ItemSpec), i=> i, StringComparer.OrdinalIgnoreCase);

NuGetPack.cs (4)

197return nuspecProperties == null ? null : NuspecPropertyStringProvider.GetNuspecPropertyProviderFunction(nuspecProperties.Select(p => p.ItemSpec).ToArray()); 376? _libPackageExcludes.Concat(AdditionalLibPackageExcludes?.Select(item => item.ItemSpec) ?? Enumerable.Empty<string>()) 377: LibPackageExcludes.Select(item => item.ItemSpec); 386.Concat(AdditionalSymbolPackageExcludes?.Select(item => item.ItemSpec) ?? Enumerable.Empty<string>());

PromoteDependencies.cs (1)

104Id = item.ItemSpec;

SplitDependenciesBySupport.cs (1)

68Name = originalItem.ItemSpec;

SplitReferences.cs (4)

66string referenceName = reference.ItemSpec; 103if (collection.TryGetValue(item.ItemSpec, out existingItem)) 110collection[item.ItemSpec] = item; 115collection[item.ItemSpec] = item;

UpdatePackageIndex.cs (4)

97_packageIdsToInclude = new HashSet<string>(PackageIds.Select(i => i.ItemSpec), StringComparer.OrdinalIgnoreCase); 135var info = GetOrCreatePackageInfo(index, baselinePackage.ItemSpec); 146var info = GetOrCreatePackageInfo(index, stablePackage.ItemSpec); 158index.ModulesToPackages[moduleToPackage.ItemSpec] = package;

ValidateHarvestVersionIsLatestForRelease.cs (1)

29Parallel.ForEach(PackageReports, (reportPath) => ValidateHarvestVersionForReport(reportPath.ItemSpec));

ValidatePackage.cs (12)

363AllSupportedFrameworks = _frameworks.Values.Where(fx => fx.SupportedVersion != null).Select(fx => fx.ToItem()).OrderBy(i => i.ItemSpec).ToArray(); 383Log.LogError($"PackageIndex from {String.Join(", ", PackageIndexes.Select(i => i.ItemSpec))} is missing an entry for package {PackageId}. Please run /t:UpdatePackageIndex on this project to commit an update."); 400Log.LogError($"PackageIndex from {String.Join(", ", PackageIndexes.Select(i => i.ItemSpec))} is missing an assembly version entry for {fileVersion} for package {PackageId}. Please run /t:UpdatePackageIndex on this project to commit an update."); 407Log.LogError($"PackageIndex from {String.Join(", ", PackageIndexes.Select(i => i.ItemSpec))} indicates that assembly version {fileVersion} is contained in non-stable package version {packageVersion} which differs from this package version {thisPackageVersion}."); 417Log.LogError($"PackageIndex from {String.Join(", ", PackageIndexes.Select(i => i.ItemSpec))} is has an assembly version entry(s) for {String.Join(", ", orphanedAssemblyVersions)} which are no longer in package {PackageId}. Please run /t:UpdatePackageIndex on this project to commit an update."); 430Log.LogError($"PackageIndex from {String.Join(", ", PackageIndexes.Select(i => i.ItemSpec))} is missing an baseline entry(s) for native module {PackageId}. Please run /t:UpdatePackageIndex on this project to commit an update."); 441Log.LogError($"PackageIndex from {String.Join(", ", PackageIndexes.Select(i => i.ItemSpec))} is missing ModulesToPackages entry(s) for {String.Join(", ", missingModuleNames)} to package {PackageId}. Please add a an entry for the appropriate package."); 463fx = FrameworkUtilities.ParseNormalized(framework.ItemSpec); 467Log.LogError($"Could not parse Framework {framework.ItemSpec}. {ex}"); 473Log.LogError($"Did not recognize {framework.ItemSpec} as valid Framework."); 500string fxString = supportedFramework.ItemSpec; 531Log.LogError($"Could not parse Version {version} on SupportedFramework item {supportedFramework.ItemSpec}. {ex}");

ValidationTask.cs (1)

105AddSuppression(suppression.ItemSpec, suppression.GetMetadata("Value"));

ApplyBaseLineTests.cs (4)

48item.ItemSpec.Should().Be("System.Runtime"); 77item.ItemSpec.Should().Be("System.Runtime"); 105item.ItemSpec.Should().Be("System.Runtime"); 134item.ItemSpec.Should().Be("System.Banana");

CreateTrimDependencyGroupsTests.cs (5)

231f.ItemSpec.Equals("System.Collections.Immutable", StringComparison.OrdinalIgnoreCase)) 237f.ItemSpec.Equals("System.Collections.Immutable", StringComparison.OrdinalIgnoreCase)) 243f.ItemSpec.Equals("System.Collections.Immutable", StringComparison.OrdinalIgnoreCase)) 249f.ItemSpec.Equals("System.Collections.Immutable", StringComparison.OrdinalIgnoreCase)) 362task.TrimmedDependencies.Should().OnlyContain(d => d.ItemSpec == "System.Collections.Immutable");

GetLastStablePackageTests.cs (6)

47item.ItemSpec.Should().Be("StableVersionTest"); 75item.ItemSpec.Should().Be("StableVersionTest"); 102item.ItemSpec.Should().Be("StableVersionTest"); 152item.ItemSpec.Should().Be("StableVersionTest"); 180item.ItemSpec.Should().Be("StableVersionTest"); 207item.ItemSpec.Should().Be("StableVersionTest");

ChooseBestP2PTargetFrameworkTask.cs (1)

107Log.LogError(string.Format(CultureInfo.CurrentCulture, "Project '{0}' targets '{1}'. It cannot be referenced by a project that targets '{2}{3}'.", project.ItemSpec, referencedProjectFrameworkString, projectNuGetFramework.DotNetFrameworkName, projectNuGetFramework.HasPlatform ? "-" + projectNuGetFramework.DotNetPlatformName : string.Empty));

ChooseBestTargetFrameworksTask.cs (2)

36NuGetFramework framework = NuGetFramework.ParseFolder(buildTargetFramework.ItemSpec); 38if (bestTargetFramework != null && (!Distinct || !bestTargetFrameworkList.Any(b => b.ItemSpec == bestTargetFramework)))

Vsix\GetPkgDefAssemblyDependencyGuid.cs (1)

45var value = string.IsNullOrEmpty(InputMetadata) ? item.ItemSpec : item.GetMetadata(InputMetadata);

Msi\MsiBase.wix.cs (2)

217SuppressIces = iceSuppressions == null ? null : string.Join(";", iceSuppressions.Select(i => i.ItemSpec)) 246string msiJsonPath = MsiProperties.Create(msi.ItemSpec);

StringExtensions.cs (1)

46str = str.Replace(item.ItemSpec, item.GetMetadata(Metadata.Replacement));

Swix\MsiSwixProject.wix.cs (3)

104return Path.Combine(relativePath, Path.GetFileName(_msi.ItemSpec)); 112FileInfo fileInfo = new(_msi.ItemSpec); 146msiWriter.WriteLine($" SystemDrive={MsiUtils.GetInstallSize(_msi.ItemSpec)}");

Swix\SwixComponent.cs (1)

158ITaskItem? resourceItem = componentResources?.Where(r => string.Equals(r.ItemSpec, workload.Id)).FirstOrDefault();

WorkloadManifestPackage.wix.cs (1)

78base(package.ItemSpec, destinationBaseDirectory, shortNames, log)

WorkloadSetPackage.wix.cs (1)

52base(package.ItemSpec, destinationBaseDirectory, shortNames, log)

CreateVisualStudioWorkloadSetTests.cs (6)

53MsiUtils.GetAllRegistryKeys(msi.ItemSpec).Should().Contain(r => 60Assert.False(MsiUtils.HasTable(msi.ItemSpec, "Upgrade")); 63DirectoryRow versionDir = MsiUtils.GetAllDirectories(msi.ItemSpec).FirstOrDefault(d => string.Equals(d.Directory, "WorkloadSetVersionDir")); 68ITaskItem workloadSetSwixItem = createWorkloadSetTask.SwixProjects.Where(s => s.ItemSpec.Contains(@"Microsoft.NET.Workloads.9.0.100.9.0.100-baseline.1.23464.1\x64")).FirstOrDefault(); 71string msiSwr = File.ReadAllText(Path.Combine(Path.GetDirectoryName(workloadSetSwixItem.ItemSpec), "msi.swr")); 82string packageGroupSwr = File.ReadAllText(Path.Combine(Path.GetDirectoryName(workloadSetPackageGroupSwixItem.ItemSpec), "packageGroup.swr"));

CreateVisualStudioWorkloadTests.cs (20)

76ITaskItem manifestMsiItem = createWorkloadTask.Msis.Where(m => m.ItemSpec.ToLowerInvariant().Contains("d96ba8044ad35589f97716ecbf2732fb-x64.msi")).FirstOrDefault(); 81Assert.Equal("{C4F269D9-6B65-36C5-9556-75B78EFE9EDA}", MsiUtils.GetProperty(manifestMsiItem.ItemSpec, MsiProperty.UpgradeCode)); 84Assert.Equal("6.33.28", MsiUtils.GetProperty(manifestMsiItem.ItemSpec, MsiProperty.ProductVersion)); 85Assert.Equal("Microsoft.NET.Workload.Emscripten,6.0.200,x64", MsiUtils.GetProviderKeyName(manifestMsiItem.ItemSpec)); 89using SummaryInfo si = new(manifestMsiItem.ItemSpec, enableWrite: false); 97i => i.ItemSpec.Contains("microsoft.net.sdk.emscripten.5.6.swixproj")).ItemSpec), "component.swr")); 102i => i.ItemSpec.Contains("microsoft.net.sdk.emscripten.pre.5.6.swixproj")).ItemSpec), "component.swr")); 143ITaskItem pythonPackSwixItem = createWorkloadTask.SwixProjects.Where(s => s.ItemSpec.Contains(@"Microsoft.Emscripten.Python.6.0.4\x64")).FirstOrDefault(); 144string packMsiSwr = File.ReadAllText(Path.Combine(Path.GetDirectoryName(pythonPackSwixItem.ItemSpec), "msi.swr")); 153Assert.All(swixComponentProjects, c => Assert.True(c.ItemSpec.Contains(".pre.") && c.GetMetadata(Metadata.IsPreview) == "true" || 154!c.ItemSpec.Contains(".pre.") && c.GetMetadata(Metadata.IsPreview) == "false")); 212ITaskItem manifestMsiItem = createWorkloadTask.Msis.Where(m => m.ItemSpec.ToLowerInvariant().Contains("d96ba8044ad35589f97716ecbf2732fb-arm64.msi")).FirstOrDefault(); 217Assert.Equal("{CBA7CF4A-F3C9-3B75-8F1F-0D08AF7CD7BE}", MsiUtils.GetProperty(manifestMsiItem.ItemSpec, MsiProperty.UpgradeCode)); 220Assert.Equal("6.33.28", MsiUtils.GetProperty(manifestMsiItem.ItemSpec, MsiProperty.ProductVersion)); 221Assert.Equal("Microsoft.NET.Workload.Emscripten,6.0.200,arm64", MsiUtils.GetProviderKeyName(manifestMsiItem.ItemSpec)); 225using SummaryInfo si = new(manifestMsiItem.ItemSpec, enableWrite: false); 232i => i.ItemSpec.Contains("microsoft.net.sdk.emscripten.5.6.swixproj")).ItemSpec), "component.swr"));

SwixPackageGroupTests.cs (1)

37string packageGroupSwr = File.ReadAllText(Path.Combine(Path.GetDirectoryName(packageGroupItem.ItemSpec), "packageGroup.swr"));

src\CreateAkaMSLinks.cs (1)

59string shortUrl = link.ItemSpec;

GenAPITask.cs (1)

415Filter = new DocIdIncludeListFilter(c.ItemSpec) { IncludeForwardedTypes = FollowTypeForwards }

GenPartialFacadeSource.cs (2)

43ReferencePaths?.Select(item => item.ItemSpec).ToArray(), 45CompileFiles?.Select(item => item.ItemSpec).ToArray(),

GenPartialFacadeSourceGenerator.cs (1)

72string key = item.ItemSpec;

NotSupportedAssemblyGenerator.cs (1)

54string sourceFile = item.ItemSpec;

FindDotNetCliPackage.cs (9)

180"sdk" => $"{feed.ItemSpec}/Sdk/{version}/dotnet-sdk-{effectiveVersion}-{Runtime}.{extension}{sasToken}", 182$"{feed.ItemSpec}/aspnetcore/Runtime/{version}/aspnetcore-runtime-{effectiveVersion}-{Runtime}.{extension}{sasToken}", 183_ => $"{feed.ItemSpec}/Runtime/{version}/dotnet-runtime-{effectiveVersion}-{Runtime}.{extension}{sasToken}" 212"sdk" => await GetMatchingProductVersionTxtContents($"{feed.ItemSpec}/Sdk/{version}", "sdk-productVersion.txt", sasToken), 213"aspnetcore-runtime" => await GetMatchingProductVersionTxtContents($"{feed.ItemSpec}/aspnetcore/Runtime/{version}", "aspnetcore-productVersion.txt", sasToken), 214_ => await GetMatchingProductVersionTxtContents($"{feed.ItemSpec}/Runtime/{version}", "runtime-productVersion.txt", sasToken) 354"sdk" => $"{feed.ItemSpec}/Sdk/{Channel}/latest.version", 355"aspnetcore-runtime" => $"{feed.ItemSpec}/aspnetcore/Runtime/{Channel}/latest.version", 356_ => $"{feed.ItemSpec}/Runtime/{Channel}/latest.version"

TaskItemExtensions.cs (1)

22log.LogError(FailureCategory.Build, $"Item '{item.ItemSpec}' missing required metadata '{key}'.");

XharnessTaskBase.cs (3)

190return (item.ItemSpec, appPathMetadata); 194return (fileSystem.GetFileNameWithoutExtension(item.ItemSpec), item.ItemSpec);

CreateXHarnessAndroidWorkItemsTests.cs (1)

225mockBundle.SetupGet(x => x.ItemSpec).Returns(itemSpec);

CreateXHarnessAppleWorkItemsTests.cs (1)

287mockBundle.SetupGet(x => x.ItemSpec).Returns(itemSpec);

GetCompatiblePackageTargetFrameworks.cs (1)

49TestProjects = testProjects.Where(tfm => tfm.ItemSpec != "").ToArray();

VerifyClosure.cs (1)

133var name = ignoredReference.ItemSpec;

VerifyTypes.cs (1)

131ignoredTypes.Add(ignoredType.ItemSpec);

src\CreateFrameworkListFile.cs (8)

64?.Select(item => new XAttribute(item.ItemSpec, item.GetMetadata("Value"))) 71item => item.ItemSpec, 84Filename = Path.GetFileName(item.ItemSpec), 86AssemblyName = FileUtilities.GetAssemblyName(item.ItemSpec), 87FileVersion = FileUtilities.GetFileVersion(item.ItemSpec), 91IsResourceFile = item.ItemSpec 98.GroupBy(f => f.Item.ItemSpec) 196Log.LogError($"No public key token found for assembly {f.Item.ItemSpec}");

src\GeneratePlatformManifestEntriesFromFileList.cs (1)

30Name = file.ItemSpec,

src\GeneratePlatformManifestEntriesFromTemplate.cs (7)

32var files = Files.ToLookup(file => Path.GetFileName(file.ItemSpec)).ToDictionary(l => l.Key, l=> l.First()); 35if (files.TryGetValue(entryTemplate.ItemSpec, out ITaskItem existingFile)) 41Name = entryTemplate.ItemSpec, 42AssemblyVersion = FileUtilities.GetAssemblyName(existingFile.ItemSpec)?.Version.ToString() ?? string.Empty, 43FileVersion = FileUtilities.GetFileVersion(existingFile.ItemSpec)?.ToString() ?? string.Empty 50var entryTemplateExtension = Path.GetExtension(entryTemplate.ItemSpec); 75Name = entryTemplate.ItemSpec,

src\GenerateSharedFrameworkDepsFile.cs (1)

61string filePath = file.ItemSpec;

src\Microsoft.DotNet.PackageTesting\VerifyClosure.cs (1)

133var name = ignoredReference.ItemSpec;

src\Microsoft.DotNet.PackageTesting\VerifyTypes.cs (1)

131ignoredTypes.Add(ignoredType.ItemSpec);

src\ValidateFileVersions.cs (2)

30var fileName = Path.GetFileName(file.ItemSpec); 79.Select(p => p.Value.File.ItemSpec)

src\SignCheckTask.cs (1)

128foreach (var checkFile in InputFiles.Select(s => s.ItemSpec).ToArray())

src\SignToolTask.cs (9)

230var filesToSkip3rdPartyCheck = ItemsToSkip3rdPartyCheck?.Select(i => i.ItemSpec).ToHashSet(StringComparer.OrdinalIgnoreCase); 237var itemsToSign = ItemsToSign.Select(i => new ItemToSign(i.ItemSpec, i.GetMetadata(SignToolConstants.CollisionPriorityId))).OrderBy(i => i.CollisionPriorityId).ToList(); 271ItemsToSkipStrongNameCheck?.Select(i => i.ItemSpec).ToArray(), 310var certificateName = certificateSignInfo.ItemSpec; 371if (!Path.IsPathRooted(itemToSign.ItemSpec)) 377var directoryParts = Path.GetFullPath(Path.GetDirectoryName(itemToSign.ItemSpec)).Split(separators); 424var extension = item.ItemSpec; 474var strongName = item.ItemSpec; 530var fileName = item.ItemSpec;

src\UsageReport\WriteUsageReports.cs (2)

173var content = File.ReadAllText(item.ItemSpec); 176Path = item.ItemSpec,

Tasks\EnsureAllResourcesTranslated.cs (1)

24string sourceDocumentPath = item.GetMetadataOrDefault(MetadataKey.SourceDocumentPath, item.ItemSpec);

Tasks\GatherXlf.cs (5)

34string sourceDocumentPath = source.GetMetadataOrDefault(MetadataKey.SourceDocumentPath, source.ItemSpec); 40xlf.SetMetadata(MetadataKey.XlfSource, source.ItemSpec); 58translatedFileName = Path.GetFileNameWithoutExtension(source.ItemSpec); 62string sourceDocumentPath = source.GetMetadataOrDefault(MetadataKey.SourceDocumentPath, source.ItemSpec); 63string extension = Path.GetExtension(source.ItemSpec);

Tasks\SortXlf.cs (1)

22string sourceDocumentPath = item.GetMetadataOrDefault(MetadataKey.SourceDocumentPath, item.ItemSpec);

Tasks\TransformTemplates.cs (4)

63string templateName = Path.GetFileNameWithoutExtension(template.ItemSpec); 73string cultureSpecificTemplateFile = Path.Combine(localizedTemplateDirectory, Path.GetFileName(template.ItemSpec)); 104Path.GetFileNameWithoutExtension(unstructuredResource.ItemSpec), 107Path.GetExtension(unstructuredResource.ItemSpec));

Tasks\TranslateSource.cs (2)

24XlfDocument xlfDocument = XlfTask.LoadXlfDocument(XlfFile.ItemSpec); 30Log.LogErrorInFile(XlfFile.ItemSpec, validationError.LineNumber, validationError.Message);

Tasks\UpdateXlf.cs (2)

31string sourcePath = item.ItemSpec; 32string sourceDocumentPath = item.GetMetadataOrDefault(MetadataKey.SourceDocumentPath, item.ItemSpec);

GetOpenApiReferenceMetadata.cs (1)

66Log.LogError(Resources.FormatInvalidEmptyMetadataValue("CodeGenerator", type, item.ItemSpec));

MetadataSerializer.cs (1)

72EscapeValue(item.ItemSpec, builder);

GetCurrentOpenApiReferenceTest.cs (1)

44Assert.Equal(expectedIdentity, output.ItemSpec);

GetOpenApiReferenceMetadataTest.cs (9)

58Assert.Equal(identity, output.ItemSpec); 118Assert.Equal(identity, output.ItemSpec); 178Assert.Equal(identity, output.ItemSpec); 238Assert.Equal(identity, output.ItemSpec); 391Assert.Equal(identity, output.ItemSpec); 455Assert.Equal(identity, output.ItemSpec); 556Assert.Equal(identity12, output.ItemSpec); 570Assert.Equal(identity12, output.ItemSpec); 583Assert.Equal(identity3, output.ItemSpec);

MetadataSerializerTest.cs (9)

126Assert.Equal(identity, item.ItemSpec); 152Assert.Equal(identity, item.ItemSpec); 167Assert.Equal(value, item.ItemSpec); 253input.SetupGet(i => i.ItemSpec).Returns(identity).Verifiable(); 266input.VerifyGet(i => i.ItemSpec, Times.Once); 280input.SetupGet(i => i.ItemSpec).Returns(identity).Verifiable(); 290input.VerifyGet(i => i.ItemSpec, Times.Once); 303input.SetupGet(i => i.ItemSpec).Returns(value).Verifiable(); 313input.VerifyGet(i => i.ItemSpec, Times.Once);

AsyncTask.cs (1)

95 LogDebugMessage(" {0}", item.ItemSpec);

CreatePartialInfoPlistTask.cs (1)

47 var fontFile = new FileInfo(font.ItemSpec);

DetectInvalidResourceOutputFilenamesTask.cs (1)

58 builder.Append($"{pair.Value} ({pair.Key.ItemSpec})");

GeneratePackageAppxManifest.cs (1)

53 var appx = XDocument.Load(AppxManifest.ItemSpec);

GetMauiAssetPath.cs (1)

48 ? Normalize(item.ItemSpec)

ResizeImageInfo.cs (1)

79 info.ItemSpec = image.ItemSpec;

UpdateRuntimeIdentifierGraph.cs (2)

38if (runtimes.ContainsKey(rid.ItemSpec)) 44runtimes.Add(rid.ItemSpec, new JObject(new JProperty("#import", new JArray(importedRids))));

TaskParameter.cs (1)

595_escapedItemSpec = EscapingUtilities.Escape(copyFrom.ItemSpec);

BackEnd\TaskParameter.cs (1)

541_escapedItemSpec = EscapingUtilities.Escape(copyFrom.ItemSpec);

ShowItems.cs (1)

42Log.LogMessage(item.ItemSpec);

Microsoft\Build\Tasks\Windows\FileClassifier.cs (1)

294ItemSpec = inputItem.ItemSpec,

Microsoft\Build\Tasks\Windows\GenerateTemporaryTargetAssembly.cs (3)

187TemporaryAssemblyForLocalTypeReference = targetOutputs[CompileTargetName][0].ItemSpec; 302TemporaryAssemblyForLocalTypeReference = targetOutputs[CompileTargetName][0].ItemSpec; 726attrInclude.Value = pItem.ItemSpec;

Microsoft\Build\Tasks\Windows\MarkupCompilePass1.cs (7)

393return SplashScreen[0].ItemSpec.ToLowerInvariant(); 938_applicationFile = TaskHelper.CreateFullFilePath(ApplicationMarkup[0].ItemSpec, SourceDir); 1020bValidItem = IsValidInputFile(inputItem.ItemSpec); 1122refpath = References[i].ItemSpec; 1462GetGeneratedFiles(inputXamlItemList[i].ItemSpec, out genLangFilePath, out bamlFile); 1532string xamlInputFullPath = TaskHelper.CreateFullFilePath(inputXamlItem.ItemSpec, SourceDir); 1668string xamlRelativeFilePath = GetResolvedFilePath(xamlItem.ItemSpec, ref tempDir);

Microsoft\Build\Tasks\Windows\MarkupCompilePass2.cs (1)

602refpath = References[i].ItemSpec;

Microsoft\Build\Tasks\Windows\MergeLocalizationDirectives.cs (1)

75using (StreamReader locStreamReader = new StreamReader(item.ItemSpec))

Microsoft\Build\Tasks\Windows\ResourcesGenerator.cs (4)

168string resourcesFile = OutputResourcesFile[0].ItemSpec; 177string resFileName = resourceFile.ItemSpec; 291strFileName = inputFile.ItemSpec; 314resFile.ItemSpec,

Microsoft\Build\Tasks\Windows\UidManager.cs (14)

Microsoft\Build\Tasks\Windows\UpdateManifestForBrowserApplication.cs (1)

72string appManifestFile = ApplicationManifest[0].ItemSpec;

MS\Internal\Tasks\CompilerState.cs (2)

214iHashCode += GetNonRandomizedHashCode(fileItemList[i].ItemSpec); 240sb.Append(fileItemList[i].ItemSpec);

MS\Internal\Tasks\IncrementalCompileAnalyzer.cs (4)

207string fileName = taskItem.ItemSpec; 463Path.GetFullPath(taskItem.ItemSpec), 494string fullPath = Path.GetFullPath(_mcPass1.ContentFiles[i].ItemSpec); 559if (IsFileChanged(fileList[i].ItemSpec))

GenerateGuid.cs (1)

26var value = string.Join(",", Values.Select(o => o.ItemSpec).ToArray()).ToLowerInvariant();

GenerateFilteredReferenceAssembliesTask.cs (4)

105ExecuteImpl(ApiSets.Select(item => (item.ItemSpec, (IReadOnlyList<string>)File.ReadAllLines(item.ItemSpec)))); 110var referencesByName = References.ToDictionary(r => Path.GetFileNameWithoutExtension(r.ItemSpec), r => r.ItemSpec);