291string ITaskItem.ItemSpec 894public string ItemSpec

769public string ItemSpec

2268public string ItemSpec { get; set; }

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

428public string ItemSpec { get; set; }

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

21public string ItemSpec { get; set; }

14public string ItemSpec { get; set; }

388string ITaskItem.ItemSpec { get; set; }

174public string ItemSpec

769public string ItemSpec

769public string ItemSpec

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

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

873OutputAssembly.ItemSpec += ".dll"; 877OutputAssembly.ItemSpec += ".netmodule"; 881OutputAssembly.ItemSpec += ".exe"; 1103item.ItemSpec = Utilities.GetFullPathNoThrow(item.ItemSpec);

3041suggestedRedirect.ItemSpec = itemSpec;

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

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

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

46item.ItemSpec = "|||";

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

95normalizedFile.ItemSpec = NormalizeTlogPath(tlogFiles[i].ItemSpec);

158using (FileStream fs = new FileStream(file.ItemSpec, FileMode.Open, FileAccess.Read)) 233MainAssembly.SetMetadata(MetadataKeys.RelativePath, Path.GetFileName(MainAssembly.ItemSpec)); 240r2rCompilationEntry.ItemSpec = r2rCompositeInputList[0].ItemSpec; 358if (!file.ItemSpec.EndsWith(".dll", StringComparison.OrdinalIgnoreCase) && !file.ItemSpec.EndsWith(".exe", StringComparison.OrdinalIgnoreCase)) 364using (FileStream fs = new FileStream(file.ItemSpec, FileMode.Open, FileAccess.Read)) 387bool excludeFromR2R = (exclusionSet != null && exclusionSet.Contains(Path.GetFileName(file.ItemSpec))); 388bool excludeFromComposite = (r2rCompositeExclusionSet != null && r2rCompositeExclusionSet.Contains(Path.GetFileName(file.ItemSpec))) || excludeFromR2R;

65return Crossgen2Tool.ItemSpec; 67return CrossgenTool.ItemSpec; 104if (!File.Exists(Crossgen2Tool.ItemSpec)) 106Log.LogError(Strings.Crossgen2ToolExecutableNotFound, Crossgen2Tool.ItemSpec); 152if (!File.Exists(CrossgenTool.ItemSpec)) 154Log.LogError(Strings.CrossgenToolExecutableNotFound, CrossgenTool.ItemSpec); 168_outputR2RImage = CompilationEntry.ItemSpec; 194_inputAssembly = CompilationEntry.ItemSpec; 232if (IsPdbCompilation && string.Equals(Path.GetFileName(reference.ItemSpec), Path.GetFileName(_outputR2RImage), StringComparison.OrdinalIgnoreCase)) 253return $"\"{Crossgen2Tool.ItemSpec}\""; 343result.AppendLine($"-m:\"{mibc.ItemSpec}\""); 371result.AppendLine(reference.ItemSpec);

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

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

102 var namespaceFilePath = NamespaceFilePath.ItemSpec; 108 var mscorlibFilePath = MscorlibFilePath.ItemSpec; 114 var cortypeFilePath = CortypeFilePath.ItemSpec; 120 var rexcepFilePath = RexcepFilePath.ItemSpec; 128 var iLLinkTrimXmlFilePath = ILLinkTrimXmlFilePath.ItemSpec; 142 OutputXml (iLLinkTrimXmlFilePath, RuntimeRootDescriptorFilePath.ItemSpec); 486 defineConstants.Add (item.ItemSpec.Trim ());

311 args.Append ("-x ").AppendLine (Quote (rootFile.ItemSpec)); 315 args.Append ("-a ").Append (Quote (assemblyItem.ItemSpec)); 352 var assemblyPath = assembly.ItemSpec; 405 var assemblyPath = assembly.ItemSpec; 423 args.Append ("-out ").AppendLine (Quote (OutputDirectory.ItemSpec)); 463 var key = customData.ItemSpec; 473 var feature = featureSetting.ItemSpec; 483 args.Append ("--keep-metadata ").AppendLine (Quote (metadata.ItemSpec)); 495 var stepPath = customStep.ItemSpec;

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

78$"| Platform |{string.Concat(Branches.Select(p => $" {p.ItemSpec} |"))}", 122return $"| **{platform.ItemSpec}**{parenthetical} |{cells}"; 130Log.LogError($"Branch '{branch.ItemSpec}' has no Abbr metadata."); 136Log.LogError($"Platform '{platform.ItemSpec}' has no Abbr metadata.");

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

189sb.Append(item.ItemSpec);

313string projectPath = FileUtilities.AttemptToShortenPath(project.ItemSpec); 343Log.LogErrorWithCodeFromResources("MSBuild.ProjectUpgradeNeededToVcxProj", project.ItemSpec); 381Log.LogMessageFromResources(MessageImportance.High, "MSBuild.ProjectFileNotFoundMessage", project.ItemSpec); 386Log.LogErrorWithCodeFromResources("MSBuild.ProjectFileNotFound", project.ItemSpec); 549string projectPath = FileUtilities.AttemptToShortenPath(projects[i].ItemSpec); 551projectNames[i] = projects[i].ItemSpec; 687outputItemFromTarget.ItemSpec = Path.Combine(projectDirectory[i], outputItemFromTarget.ItemSpec); 691log.LogWarningWithCodeFromResources(null, projects[i].ItemSpec, 0, 0, 0, 0, "MSBuild.CannotRebaseOutputItemPath", outputItemFromTarget.ItemSpec, e.Message);

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

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

133yield return taskItem.ItemSpec;

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

1016if (item is ITaskItem taskItem && !string.IsNullOrEmpty(taskItem.ItemSpec)) 1018EmbedFile.Invoke(taskItem.ItemSpec); 1029WriteDeduplicatedString(item.ItemSpec);

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

394WriteLinePretty(ResourceUtilities.FormatResourceStringIgnoreCodeAndKeyword("TargetOutputItem", item.ItemSpec));

821project.OutputPath = output.ItemSpec.AsMemory();

1094writer.Write(taskItem.ItemSpec);

315escapedItemSpec = EscapingUtilities.Escape(copyFrom.ItemSpec); 419escapedItemSpec = EscapingUtilities.Escape(wrappedItem.ItemSpec);

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

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

453Assert.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}')"); 3724Assert.Equal("InitialValue", results.ResultsByTarget["BuildOther"].Items.First().ItemSpec); 3746Assert.Equal(newPropertyValue, results.ResultsByTarget["Foo"].Items.First().ItemSpec); 3810string.Join(";", result.ResultsByTarget["MainTarget"].Items.Select(i => i.ItemSpec)));

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

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

385Assert.Equal("foo.o", results.Items[0].ItemSpec); 405Assert.Equal("testProject.proj", results.Items[0].ItemSpec); 736Assert.Equal("item1", outputListB[0].ItemSpec); 748Assert.Equal("item2", outputListC[0].ItemSpec);

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

865ValidateOutputProperty("ItemOutput", _oneItem[0].ItemSpec); 885ValidateOutputProperty("ItemArrayOutput", String.Concat(_twoItems[0].ItemSpec, ";", _twoItems[1].ItemSpec)); 1380Assert.Equal(value, actualItem.ItemSpec); 1408Assert.Equal(value, actualItems[0].ItemSpec); 1443Assert.Equal(expectedItems[i], actualItems[i].ItemSpec);

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

202sb.Append(taskItem.ItemSpec);

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

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);

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

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

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

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();

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

198Assert.Equal("foo", foo.ItemSpec); 207Assert.Equal("foo", foo2.ItemSpec); 226Assert.Equal("foo", foo.ItemSpec); 237Assert.Equal("foo", foo2.ItemSpec); 255Assert.Equal("foo", wrappedParameter[0].ItemSpec); 256Assert.Equal("bar", wrappedParameter[1].ItemSpec); 266Assert.Equal("foo", wrappedParameter2[0].ItemSpec); 267Assert.Equal("bar", wrappedParameter2[1].ItemSpec); 283Assert.Equal("foo;bar", foo.ItemSpec); 292Assert.Equal("foo;bar", foo2.ItemSpec); 308Assert.Equal("foo%3bbar", foo.ItemSpec); 317Assert.Equal("foo%3bbar", foo2.ItemSpec); 328Assert.Equal("foo%3bbar", foo4.ItemSpec); 344Assert.Equal("foo;bar", foo.ItemSpec); 354Assert.Equal("foo;bar", foo2.ItemSpec); 375Assert.Equal("foo", foo.ItemSpec); 386Assert.Equal("foo", foo2.ItemSpec); 408Assert.Equal("foo", foo.ItemSpec); 419Assert.Equal("foo", foo2.ItemSpec); 432Assert.Equal("foo", foo4.ItemSpec); 455Assert.Equal("foo", foo.ItemSpec); 468Assert.Equal("foo", foo2.ItemSpec);

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

63EvaluatedInclude = ti.ItemSpec;

36ItemSpec = original.ItemSpec;

214writer.Write(taskItem.ItemSpec);

248AppendSwitchIfNotNull(switchName, parameter.ItemSpec);

274commandLine.AppendSwitchIfNotNull("@", response.ItemSpec); 357appendGlobalReference(reference.ItemSpec); 389reference.ItemSpec, 397appendGlobalReference(reference.ItemSpec); 404commandLine.AppendSwitchAliased(switchName, trimmedAlias, reference.ItemSpec); 422commandLine.AppendSwitchForceQuoted(switchName, reference.ItemSpec); 426commandLine.AppendSwitchIfNotNull(switchName, reference.ItemSpec);

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;

212commandLine.AppendSwitchIfNotNull("@", response.ItemSpec); 230commandLine.AppendSwitchIfNotNull("@", scriptResponse.ItemSpec);

865OutputAssembly = new TaskItem(Path.GetFileNameWithoutExtension(Sources[0].ItemSpec)); 980commandLine.AppendSwitchIfNotNull("/analyzer:", analyzer.ItemSpec); 993commandLine.AppendSwitchIfNotNull("/additionalfile:", additionalFile.ItemSpec); 1012commandLine.AppendSwitchIfNotNull("/embed:", embeddedFile.ItemSpec); 1026commandLine.AppendSwitchIfNotNull("/analyzerconfig:", analyzerConfigFile.ItemSpec); 1103item.ItemSpec = Utilities.GetFullPathNoThrow(item.ItemSpec); 1171if (!File.Exists(reference.ItemSpec)) 1174Log.LogErrorWithCodeFromResources("General_ReferenceDoesNotExist", reference.ItemSpec);

99if (!EndsWithDirectorySeparator(sourceRoot.ItemSpec)) 101Log.LogErrorFromResources("MapSourceRoots.PathMustEndWithSlashOrBackslash", Names.SourceRoot, sourceRoot.ItemSpec); 104if (rootByItemSpec.TryGetValue(sourceRoot.ItemSpec, out var existingRoot)) 111rootByItemSpec.Add(sourceRoot.ItemSpec, sourceRoot); 130string localPath = root.ItemSpec; 190root.SetMetadata(Names.MappedPath, root.ItemSpec); 214Log.LogWarningFromResources("MapSourceRoots.ContainsDuplicate", Names.SourceRoot, left.ItemSpec, metadataName, leftValue, rightValue);

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

279MovePdbFileIfNecessary(OutputAssembly?.ItemSpec); 549commandLine.AppendSwitchIfNotNull("@", response.ItemSpec); 854CheckHostObjectSupport(param = nameof(OutputAssembly), vbcHostObject.SetOutputAssembly(OutputAssembly?.ItemSpec));

19=> $"'{sourceRoot.ItemSpec}'" + 60Assert.Equal(Utilities.FixFilePath(@"c:\packages\SourcePackage1\"), task.MappedSourceRoots[0].ItemSpec); 63Assert.Equal(Utilities.FixFilePath(@"/packages/SourcePackage2/"), task.MappedSourceRoots[1].ItemSpec); 66Assert.Equal(Utilities.FixFilePath(@"c:\MyProjects\MyProject\"), task.MappedSourceRoots[2].ItemSpec); 70Assert.Equal(Utilities.FixFilePath(@"c:\MyProjects\MyProject\a\b\"), task.MappedSourceRoots[3].ItemSpec); 109Assert.Equal(Utilities.FixFilePath(@"!@#:;$%^&*()_+|{}\"), task.MappedSourceRoots[0].ItemSpec); 112Assert.Equal(Utilities.FixFilePath("****/"), task.MappedSourceRoots[1].ItemSpec); 116Assert.Equal(Utilities.FixFilePath(@"****\|||:;\"), task.MappedSourceRoots[2].ItemSpec); 186Assert.Equal(Utilities.FixFilePath(@"c:\MyProjects\MyProject\"), task.MappedSourceRoots[0].ItemSpec); 189Assert.Equal(Utilities.FixFilePath(@"c:\MyProjects\MyProject\a\a\"), task.MappedSourceRoots[1].ItemSpec); 192Assert.Equal(Utilities.FixFilePath(@"c:\MyProjects\MyProject\a\b\"), task.MappedSourceRoots[2].ItemSpec); 195Assert.Equal(Utilities.FixFilePath(@"c:\MyProjects\MyProject\a\c\"), task.MappedSourceRoots[3].ItemSpec); 224Assert.Equal(Utilities.FixFilePath(@"c:\packages\SourcePackage1\"), task.MappedSourceRoots[0].ItemSpec); 227Assert.Equal(Utilities.FixFilePath(@"C:\packages\SourcePackage1\"), task.MappedSourceRoots[1].ItemSpec); 230Assert.Equal(Utilities.FixFilePath(@"c:\packages\SourcePackage2\"), task.MappedSourceRoots[2].ItemSpec);

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

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

92if (string.IsNullOrEmpty(ApplicationManifest.ItemSpec) || !File.Exists(ApplicationManifest?.ItemSpec)) 94Log.LogErrorWithCodeFromResources(null, ApplicationManifest?.ItemSpec, 0, 0, 0, 0, "AddToWin32Manifest.SpecifiedApplicationManifestCanNotBeFound"); 98return ApplicationManifest!.ItemSpec; 138SaveManifest(document, Path.GetFileName(ApplicationManifest?.ItemSpec) ?? DefaultManifestName);

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;

152string itemSpec = sourceItem.ItemSpec;

571string itemSpec = referenceAssemblyName.ItemSpec; 704return new InvalidReferenceAssemblyNameException(referenceAssemblyName.ItemSpec); 885string itemSpec = referenceAssemblyFile.ItemSpec; 914throw new InvalidParameterValueException("AssemblyFiles", referenceAssemblyFile.ItemSpec, e.Message); 1507string dependeeItemSpec = dependee.ItemSpec; 1512if (string.Equals(dependeeItemSpec, assemblyReference.PrimarySourceItem.ItemSpec, StringComparison.OrdinalIgnoreCase)) 1568if (assemblyReference.IsPrimary && assemblyReference.PrimarySourceItem.ItemSpec.Equals(itemSpec, StringComparison.OrdinalIgnoreCase)) 3080_log.LogWarningWithCodeFromResources("ResolveAssemblyReference.PrimaryReferenceOutsideOfFramework", reference.PrimarySourceItem.ItemSpec /* primary item spec*/, reference.ReferenceVersion /*Version of dependent assembly*/, reference.ExclusionListLoggingProperties.HighestVersionInRedist /*Version found in redist*/); 3084_log.LogWarningWithCodeFromResources("ResolveAssemblyReference.DependencyReferenceOutsideOfFramework", referenceItem.ItemSpec /* primary item spec*/, assemblyName.FullName /*Dependent assemblyName*/, reference.ReferenceVersion /*Version of dependent assembly*/, reference.ExclusionListLoggingProperties.HighestVersionInRedist /*Version found in redist*/); 3095_log.LogWarningWithCodeFromResources("ResolveAssemblyReference.PrimaryReferenceOutsideOfFrameworkUsingAttribute", reference.PrimarySourceItem.ItemSpec /* primary item spec*/, reference.FrameworkNameAttribute /*Version of dependent assembly*/, targetedFramework); 3099_log.LogWarningWithCodeFromResources("ResolveAssemblyReference.DependencyReferenceOutsideOfFrameworkUsingAttribute", referenceItem.ItemSpec /* primary item spec*/, assemblyName.FullName /*Dependent assemblyName*/, reference.FrameworkNameAttribute, targetedFramework); 3110_log.LogWarningWithCodeFromResources("ResolveAssemblyReference.PrimaryReferenceInAnotherFramework", reference.PrimarySourceItem.ItemSpec /* primary item spec*/, targetedFramework); 3114_log.LogWarningWithCodeFromResources("ResolveAssemblyReference.DependencyReferenceInAnotherFramework", referenceItem.ItemSpec /* primary item spec*/, assemblyName.FullName /*Dependent assemblyName*/, targetedFramework); 3125_log.LogWarningWithCodeFromResources("ResolveAssemblyReference.FailedToResolveReferenceBecausePrimaryAssemblyInExclusionList", reference.PrimarySourceItem.ItemSpec, targetedFramework); 3129_log.LogWarningWithCodeFromResources("ResolveAssemblyReference.FailBecauseDependentAssemblyInExclusionList", referenceItem.ItemSpec, assemblyName.FullName, targetedFramework);

1395log.AppendLine().Append(Strings.TwelveSpaces).Append(sourceItem.ItemSpec); 1500Log.LogMessage(importance, indent + item.ItemSpec); 1512Log.LogMessage(importance, indent + item.ItemSpec); 1906Log.LogMessage(importance, Strings.RequiredBy, dependee.ItemSpec); 2635if (fileExists(item.ItemSpec) && !Reference.IsFrameworkFile(item.ItemSpec, _targetFrameworkDirectories)) 2639assemblyName = getAssemblyName(item.ItemSpec); 2802Log.LogErrorWithCodeFromResources("ResolveAssemblyReference.FrameworkDirectoryOnProfiles", item.ItemSpec); 2871string fileName = subsetItems.ItemSpec; 3093tableMap[installedAssemblyTable.ItemSpec] = new AssemblyTableInfo(installedAssemblyTable.ItemSpec, frameworkDirectory); 3150Log.LogMessageFromResources(MessageImportance.Normal, "ResolveAssemblyReference.IgnoringBecauseNonEmptySubtype", assembly.ItemSpec, subType); 3154Log.LogWarningWithCodeFromResources("ResolveAssemblyReference.FailedToResolveReferenceBecauseHigherTargetFramework", assembly.ItemSpec, assembly.GetMetadata(ItemMetadataNames.targetFramework));

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

161AssignedFiles[i].ItemSpec, 173existingCulture, AssignedFiles[i].ItemSpec, info.culture); 201AssignedFiles[i].ItemSpec); 205Log.LogErrorWithCodeFromResources("AssignCulture.CannotExtractCulture", Files[i].ItemSpec, e.Message);

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

91!Path.IsPathRooted(Files[i].ItemSpec) && 93!Files[i].ItemSpec.Contains("." + Path.DirectorySeparatorChar) && 101targetPath = Files[i].ItemSpec; 107string itemSpecFullFileNamePath = Path.GetFullPath(Files[i].ItemSpec); 117targetPath = Path.GetFileName(Files[i].ItemSpec);

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

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

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

245AppendSwitchIfNotNull(switchName, parameter.ItemSpec);

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

500string destPath = DestinationFiles[i].ItemSpec; 504if (String.Equals(originalSource, SourceFiles[i].ItemSpec, StringComparison.OrdinalIgnoreCase)) 513if (DoCopyIfNecessary(new FileState(SourceFiles[i].ItemSpec), new FileState(DestinationFiles[i].ItemSpec), copyFile)) 515filesActuallyCopied[destPath] = SourceFiles[i].ItemSpec; 593string destPath = destItem.ItemSpec; 646string sourcePath = sourceItem.ItemSpec; 649MSBuildEventSource.Log.CopyUpToDateStart(destItem.ItemSpec); 653SourceFiles[partition[partitionIndex - 1]].ItemSpec, 659new FileState(sourceItem.ItemSpec), 660new FileState(destItem.ItemSpec), 673MSBuildEventSource.Log.CopyUpToDateStop(destItem.ItemSpec, true); 776() => Path.Combine(DestinationFolder.ItemSpec, Path.GetFileName(SourceFiles[i].ItemSpec)), 777SourceFiles[i].ItemSpec, 778DestinationFolder.ItemSpec, 802string src = FileUtilities.NormalizePath(sourceFolder.ItemSpec); 815sourceFolder.ItemSpec, 816DestinationFolder.ItemSpec, 824() => Path.Combine(DestinationFolder.ItemSpec, srcName, file), 825sourceFolder.ItemSpec, 826DestinationFolder.ItemSpec, 1009if (DestinationFolder != null && FileSystems.Default.FileExists(DestinationFolder.ItemSpec))

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;

157string fileName = resourceFile.ItemSpec; 221itemSpecToTaskitem[resourceFile.ItemSpec] = resourceFile; 256Log.LogErrorWithCodeFromResources("CreateManifestResourceName.Error", resourceFile.ItemSpec, e.Message);

118while (!deletedFilesSet.Contains(file.ItemSpec)) 122if (FileSystems.Default.FileExists(file.ItemSpec)) 126Log.LogWarningFromResources("Delete.DeletingFile", file.ItemSpec); 131Log.LogMessageFromResources(MessageImportance.Normal, "Delete.DeletingFile", file.ItemSpec); 134File.Delete(file.ItemSpec); 138Log.LogMessageFromResources(MessageImportance.Low, "Delete.SkippingNonexistentFile", file.ItemSpec); 145deletedFilesSet.Add(file.ItemSpec); 149string lockedFileMessage = LockCheck.GetLockedFileMessage(file?.ItemSpec ?? string.Empty); 162deletedFilesSet.Add(file.ItemSpec); 182Log.LogWarningWithCodeFromResources("Delete.Error", file.ItemSpec, e.Message, lockedFileMessage); 186Log.LogErrorWithCodeFromResources("Delete.Error", file.ItemSpec, e.Message, lockedFileMessage);

178DirectoryInfo destinationDirectory = Directory.CreateDirectory(DestinationFolder.ItemSpec); 324filename = !String.IsNullOrWhiteSpace(DestinationFileName?.ItemSpec) 325? DestinationFileName.ItemSpec // Get the file name from what the user specified

88if (!FileSystems.Default.FileExists(file.ItemSpec)) 90Log.LogErrorWithCodeFromResources("FileHash.FileNotFound", file.ItemSpec); 94var hash = ComputeHash(algorithmFactory, file.ItemSpec, _cancellationTokenSource.Token);

41if (FileSystems.Default.FileExists(File.ItemSpec)) 45string[] textLines = System.IO.File.ReadAllLines(File.ItemSpec); 69Log.LogErrorWithCodeFromResources("ReadLinesFromFile.ErrorOrWarning", File.ItemSpec, e.Message);

79buffer.AppendLine(line.ItemSpec); 99var directoryPath = Path.GetDirectoryName(FileUtilities.NormalizePath(File.ItemSpec)); 111if (FileUtilities.FileExistsNoThrow(File.ItemSpec)) 113string existingContents = System.IO.File.ReadAllText(File.ItemSpec); 118Log.LogMessageFromResources(MessageImportance.Low, "WriteLinesToFile.SkippingUnchangedFile", File.ItemSpec); 119MSBuildEventSource.Log.WriteLinesToFileUpToDateStop(File.ItemSpec, true); 124Log.LogErrorWithCodeFromResources("WriteLinesToFile.ErrorReadingFile", File.ItemSpec); 132Log.LogMessageFromResources(MessageImportance.Low, "WriteLinesToFile.ErrorReadingFile", File.ItemSpec); 134MSBuildEventSource.Log.WriteLinesToFileUpToDateStop(File.ItemSpec, false); 137System.IO.File.WriteAllText(File.ItemSpec, contentsAsString, encoding); 143Log.LogMessageFromResources(MessageImportance.Normal, "WriteLinesToFile.UnusedWriteOnlyWhenDifferent", File.ItemSpec); 147System.IO.File.AppendAllText(File.ItemSpec, buffer.ToString(), encoding); 152string lockedFileMessage = LockCheck.GetLockedFileMessage(File.ItemSpec); 153Log.LogErrorWithCodeFromResources("WriteLinesToFile.ErrorOrWarning", File.ItemSpec, e.Message, lockedFileMessage);

124string filename = (matchWholeItemSpec ? item.ItemSpec : Path.GetFileName(item.ItemSpec)); 133AppConfigFile.SetMetadata("OriginalItemSpec", item.ItemSpec); 137Log.LogMessageFromResources(MessageImportance.Low, "FindInList.Found", AppConfigFile.ItemSpec); 145Log.LogMessageFromResources(MessageImportance.Low, "FindInList.InvalidPath", item.ItemSpec, ex.Message);

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

92string referenceIdentity = item.ItemSpec;

233name = Path.GetFileName(item.ItemSpec); 236if (!file.ImportComComponent(item.ItemSpec, manifest.OutputMessages, name)) 257Extension = item.ItemSpec, 271if (!String.IsNullOrEmpty(ConfigFile?.ItemSpec)) 276if (!String.IsNullOrEmpty(IconFile?.ItemSpec)) 281if (!String.IsNullOrEmpty(TrustInfoFile?.ItemSpec)) 284manifest.TrustInfo.Read(TrustInfoFile.ItemSpec); 444if (String.IsNullOrEmpty(InputManifest?.ItemSpec) || String.CompareOrdinal(InputManifest.ItemSpec, "NoManifest") == 0) 451using (Stream s = File.Open(InputManifest.ItemSpec, FileMode.Open, FileAccess.Read, FileShare.Read)) 478Log.LogErrorWithCodeFromResources("GenerateManifest.ReadInputManifestFailed", InputManifest.ItemSpec, ex.Message);

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

87AssemblyIdentity = AssemblyIdentity.FromAssemblyName(item.ItemSpec), 120assembly = _manifest.AssemblyReferences.Add(item.ItemSpec); 125AssemblyIdentity identity = AssemblyIdentity.FromAssemblyName(item.ItemSpec); 133assembly = new AssemblyReference(item.ItemSpec); 151AssemblyReference assembly = _manifest.AssemblyReferences.Add(item.ItemSpec); 159FileReference file = _manifest.FileReferences.Add(item.ItemSpec); 337targetPath = BaseReference.GetDefaultTargetPath(item.ItemSpec); 372Log.LogWarningWithCodeFromResources("GenerateManifest.InvalidItemValue", "AssemblyType", item.ItemSpec); 376Log.LogWarningWithCodeFromResources("GenerateManifest.InvalidItemValue", "AssemblyType", item.ItemSpec); 403Log.LogWarningWithCodeFromResources("GenerateManifest.InvalidItemValue", "DependencyType", item.ItemSpec); 407Log.LogWarningWithCodeFromResources("GenerateManifest.InvalidItemValue", "DependencyType", item.ItemSpec); 417return OutputManifest.ItemSpec; 435if (String.IsNullOrEmpty(InputManifest?.ItemSpec)) 454_manifest = ManifestReader.ReadManifest(manifestType.Name, InputManifest.ItemSpec, true); 458Log.LogErrorWithCodeFromResources("GenerateManifest.ReadInputManifestFailed", InputManifest.ItemSpec, ex.Message); 484if (!String.IsNullOrEmpty(EntryPoint?.ItemSpec)) 592string manifestFileName = Path.GetFileName(OutputManifest.ItemSpec); 617ManifestWriter.WriteManifest(_manifest, OutputManifest.ItemSpec, TargetFrameworkVersion); 621string lockedFileMessage = LockCheck.GetLockedFileMessage(OutputManifest.ItemSpec); 622Log.LogErrorWithCodeFromResources("GenerateManifest.WriteOutputManifestFailed", OutputManifest.ItemSpec, ex.Message, lockedFileMessage); 628Util.WriteLog($"Total time to generate manifest '{Path.GetFileName(OutputManifest.ItemSpec)}': t={Environment.TickCount - _startTime}");

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); 1475Log.LogErrorWithCodeFromResources("GenerateResource.DuplicateOutputFilenames", item.ItemSpec); 1481Log.LogErrorWithCodeFromResources("GenerateResource.InvalidFilename", item.ItemSpec, e.Message); 1712DateTime time = NativeMethodsShared.GetLastWriteFileUtcTime(input.ItemSpec); 1717_newestUncorrelatedInput = input.ItemSpec; 1726_newestUncorrelatedInput = input.ItemSpec; 2440string outputSpec = _extractResWFiles ? resWOutputDirectory : _outFiles[i].ItemSpec; 2441if (!ProcessFile(_inFiles[i].ItemSpec, outputSpec)) 2526if (assemblyFile.ItemSpec != null && FileSystems.Default.FileExists(assemblyFile.ItemSpec)) 2542_assemblyNames[i] = new AssemblyNameExtension(Path.GetFileNameWithoutExtension(assemblyFile.ItemSpec));

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

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

260string rootDirectory = resolvedSDKReference.ItemSpec; 266Log.LogErrorWithCodeFromResources("GetSDKReferenceFiles.CannotHaveEmptyTargetConfiguration", resolvedSDKReference.ItemSpec); 272Log.LogErrorWithCodeFromResources("GetSDKReferenceFiles.CannotHaveEmptyTargetArchitecture", resolvedSDKReference.ItemSpec); 309redistPaths = ToolLocationHelper.GetSDKRedistFolders(resolvedSDKReference.ItemSpec, targetedConfiguration, targetedArchitecture); 316Log.LogMessageFromResources(MessageImportance.Low, "GetSDKReferenceFiles.ExpandRedistFrom", path.Replace(resolvedSDKReference.ItemSpec, String.Empty)); 337Log.LogMessageFromResources("GetSDKReferenceFiles.AddingRedistFile", redist.RedistFile.Replace(redist.SDKReferenceItem.ItemSpec, String.Empty), redist.TargetPath); 384IList<string> referencePaths = ToolLocationHelper.GetSDKReferenceFolders(resolvedSDKReference.ItemSpec, targetedConfiguration, targetedArchitecture); 390Log.LogMessageFromResources(MessageImportance.Low, "GetSDKReferenceFiles.ExpandReferencesFrom", path.Replace(resolvedSDKReference.ItemSpec, String.Empty)); 411Log.LogMessageFromResources("GetSDKReferenceFiles.AddingReference", reference.AssemblyLocation.Replace(reference.SDKReferenceItem.ItemSpec, String.Empty)); 470outputItem.SetMetadata("SDKRootPath", reference.SDKReferenceItem.ItemSpec); 546outputItem.SetMetadata("SDKRootPath", file.SDKReferenceItem.ItemSpec); 599Log.LogMessageFromResources("GetSDKReferenceFiles.ConflictReferenceSameSDK", winner.SDKReferenceItem.GetMetadata("OriginalItemSpec"), winner.AssemblyLocation.Replace(winner.SDKReferenceItem.ItemSpec, String.Empty), resolvedReference.AssemblyLocation.Replace(resolvedReference.SDKReferenceItem.ItemSpec, String.Empty)); 603string message = ResourceUtilities.FormatResourceStringStripCodeAndKeyword("GetSDKReferenceFiles.ConflictReferenceSameSDK", winner.SDKReferenceItem.GetMetadata("OriginalItemSpec"), winner.AssemblyLocation.Replace(winner.SDKReferenceItem.ItemSpec, String.Empty), resolvedReference.AssemblyLocation.Replace(resolvedReference.SDKReferenceItem.ItemSpec, String.Empty)); 639Log.LogMessageFromResources("GetSDKReferenceFiles.ConflictRedistSameSDK", redistFile.TargetPath, redistFile.SDKReferenceItem.GetMetadata("OriginalItemSpec"), winner.RedistFile.Replace(redistFile.SDKReferenceItem.ItemSpec, String.Empty), redistFile.RedistFile.Replace(redistFile.SDKReferenceItem.ItemSpec, String.Empty)); 643string message = ResourceUtilities.FormatResourceStringStripCodeAndKeyword("GetSDKReferenceFiles.ConflictRedistSameSDK", redistFile.TargetPath, redistFile.SDKReferenceItem.GetMetadata("OriginalItemSpec"), winner.RedistFile.Replace(redistFile.SDKReferenceItem.ItemSpec, String.Empty), redistFile.RedistFile.Replace(redistFile.SDKReferenceItem.ItemSpec, String.Empty)); 664ErrorUtilities.VerifyThrowArgument(sdkIdentity.Length != 0, "GetSDKReferenceFiles.NoOriginalItemSpec", sdk.ItemSpec); 665string sdkRoot = sdk.ItemSpec;

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

56string sdkDirectory = resolvedSDK.ItemSpec;

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

62System.IO.Path.GetFullPath(FileUtilities.FixFilePath(Path.ItemSpec))); 68"FindUnderPath.InvalidParameter", "Path", Path.ItemSpec, e.Message); 74Log.LogMessageFromResources(MessageImportance.Low, "FindUnderPath.ComparisonPath", Path.ItemSpec); 83System.IO.Path.GetFullPath(FileUtilities.FixFilePath(item.ItemSpec))); 88"FindUnderPath.InvalidParameter", "Files", item.ItemSpec, e.Message);

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

54if (directory.ItemSpec.Length > 0) 59if (!directoriesSet.Contains(directory.ItemSpec)) 62if (!FileUtilities.DirectoryExistsNoThrow(directory.ItemSpec)) 66Log.LogErrorFromResources("MakeDir.Comment", directory.ItemSpec); 71Log.LogMessageFromResources(MessageImportance.Normal, "MakeDir.Comment", directory.ItemSpec); 73Directory.CreateDirectory(FileUtilities.FixFilePath(directory.ItemSpec)); 82Log.LogErrorWithCodeFromResources("MakeDir.Error", directory.ItemSpec, e.Message); 86directoriesSet.Add(directory.ItemSpec);

416if (String.IsNullOrEmpty(item.ItemSpec)) 422var id = new AssemblyIdentity(item.ItemSpec); 429key = Path.GetFullPath(item.ItemSpec).ToUpperInvariant(); 607if (item1.ItemSpec == null || item2.ItemSpec == null) 612return String.Compare(item1.ItemSpec, item2.ItemSpec, StringComparison.Ordinal);

46throw new ArgumentException(ResourceUtilities.FormatResourceStringStripCodeAndKeyword("General.InvalidAttributeMetadata", item.ItemSpec, itemMetadataName, metadataValue, "bool"), e);

133destinationFile = Path.Combine(DestinationFolder.ItemSpec, Path.GetFileName(SourceFiles[i].ItemSpec)); 137Log.LogErrorWithCodeFromResources("Move.Error", SourceFiles[i].ItemSpec, DestinationFolder.ItemSpec, e.Message, string.Empty); 155string sourceFile = SourceFiles[i].ItemSpec; 156string destinationFile = DestinationFiles[i].ItemSpec;

279string projectPath = FileUtilities.AttemptToShortenPath(project.ItemSpec); 309Log.LogErrorWithCodeFromResources("MSBuild.ProjectUpgradeNeededToVcxProj", project.ItemSpec); 345Log.LogMessageFromResources(MessageImportance.High, "MSBuild.ProjectFileNotFoundMessage", project.ItemSpec); 350Log.LogErrorWithCodeFromResources("MSBuild.ProjectFileNotFound", project.ItemSpec); 506string projectPath = FileUtilities.AttemptToShortenPath(projects[i].ItemSpec); 508projectNames[i] = projects[i].ItemSpec; 636outputItemFromTarget.ItemSpec = Path.Combine(projectDirectory[i], outputItemFromTarget.ItemSpec); 640log.LogWarningWithCodeFromResources(null, projects[i].ItemSpec, 0, 0, 0, 0, "MSBuild.CannotRebaseOutputItemPath", outputItemFromTarget.ItemSpec, e.Message);

56if (string.IsNullOrEmpty(directory.ItemSpec)) 64if (FileSystems.Default.DirectoryExists(directory.ItemSpec)) 68Log.LogErrorFromResources("RemoveDir.Removing", directory.ItemSpec); 73Log.LogMessageFromResources(MessageImportance.Normal, "RemoveDir.Removing", directory.ItemSpec); 84currentSuccess = RemoveReadOnlyAttributeRecursively(new DirectoryInfo(directory.ItemSpec)); 102Log.LogMessageFromResources(MessageImportance.Normal, "RemoveDir.SkippingNonexistentDirectory", directory.ItemSpec); 123Directory.Delete(directory.ItemSpec, true); 137Log.LogErrorWithCodeFromResources("RemoveDir.Error", directory.ItemSpec, e.Message);

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

176_runtimePackAssets = RuntimePackAssets.ToDictionary(p => p.ItemSpec, StringComparer.OrdinalIgnoreCase); 264ITaskItem outputItem = new TaskItem(item.ItemSpec); 287ITaskItem outputItem = new TaskItem(item.ItemSpec); 291targetPath = Path.GetFileName(item.ItemSpec); 328ITaskItem outputItem = new TaskItem(item.ItemSpec); 352string[] pathSegments = PathUtil.GetPathSegments(item.ItemSpec); 354Debug.Assert(!String.IsNullOrEmpty(itemCulture), $"Satellite item '{item.ItemSpec}' is missing expected attribute 'Culture'"); 369targetPath = Path.GetFileName(item.ItemSpec); 404AssemblyIdentity identity = AssemblyIdentity.FromManagedAssembly(item.ItemSpec); 510var outputAssembliesMap = outputAssemblies.ToDictionary(p => Path.GetFullPath(p.ItemSpec), StringComparer.OrdinalIgnoreCase); 522string key = Path.GetFullPath(item.ItemSpec); 584string fileExtension = Path.GetExtension(entry.item.ItemSpec); 672var outputEntryPoint = new TaskItem(entryPoint.ItemSpec); 735Log.LogWarningWithCodeFromResources("GenerateManifest.InvalidItemValue", "FileType", item.ItemSpec); 750_runtimePackAssets.TryGetValue(item.ItemSpec, out _)) 760AssemblyIdentity identity = AssemblyIdentity.FromManagedAssembly(item.ItemSpec); 761if (item.ItemSpec.EndsWith(".dll") && identity == null && !isDotNetCore) 809this.key = item.ItemSpec?.ToLowerInvariant(); 860fusionName = Path.Combine(destSubDir, Path.GetFileNameWithoutExtension(item.ItemSpec)); 864fusionName = Path.GetFileNameWithoutExtension(item.ItemSpec); 913AssemblyIdentity identity = AssemblyIdentity.FromManagedAssembly(item.ItemSpec); 924AssemblyIdentity identity = AssemblyIdentity.FromManagedAssembly(item.ItemSpec);

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);

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

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));

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

56SigningTarget.ItemSpec,

94string path = FileUtilities.FixFilePath(file.ItemSpec);

90destinationDirectory = Directory.CreateDirectory(DestinationFolder.ItemSpec); 94Log.LogErrorWithCodeFromResources("Unzip.ErrorCouldNotCreateDestinationDirectory", DestinationFolder.ItemSpec, e.Message); 109if (!FileSystems.Default.FileExists(sourceFile.ItemSpec)) 111Log.LogErrorWithCodeFromResources("Unzip.ErrorFileDoesNotExist", sourceFile.ItemSpec); 117using (FileStream stream = new FileStream(sourceFile.ItemSpec, FileMode.Open, FileAccess.Read, FileShare.Read, bufferSize: 0x1000, useAsync: false)) 143Log.LogErrorWithCodeFromResources("Unzip.ErrorCouldNotOpenFile", sourceFile.ItemSpec, e.Message);

109if (OutputFile != null && OutputDirectory != null && !Path.IsPathRooted(OutputFile.ItemSpec)) 111OutputFile = new TaskItem(Path.Combine(OutputDirectory.ItemSpec, OutputFile.ItemSpec)); 114OutputFile ??= new TaskItem(FileUtilities.GetTemporaryFile(OutputDirectory.ItemSpec, null, extension)); 116FileUtilities.EnsureDirectoryExists(Path.GetDirectoryName(OutputFile.ItemSpec)); 118File.WriteAllText(OutputFile.ItemSpec, code); // Overwrites file if it already exists (and can be overwritten) 122string itemSpec = OutputFile?.ItemSpec ?? String.Empty; 128Log.LogMessageFromResources(MessageImportance.Low, "WriteCodeFragment.GeneratedFile", OutputFile.ItemSpec); 260var attribute = new CodeAttributeDeclaration(new CodeTypeReference(attributeItem.ItemSpec));

89Log.LogErrorWithCodeFromResources("XmlPeekPoke.InputFileError", XmlInputPath.ItemSpec, e.Message); 248_data = xmlInputPath.ItemSpec;

66using (FileStream fs = new FileStream(XmlInputPath.ItemSpec, FileMode.Open, FileAccess.Read, FileShare.ReadWrite)) 77Log.LogErrorWithCodeFromResources("XmlPeekPoke.InputFileError", XmlInputPath.ItemSpec, e.Message); 127iter.Current.InnerXml = Value.ItemSpec; 128Log.LogMessageFromResources(MessageImportance.Low, "XmlPoke.Replaced", iter.Current.Name, Value.ItemSpec); 132Log.LogErrorWithCodeFromResources("XmlPoke.PokeError", Value.ItemSpec, e.Message); 142using (Stream stream = File.Create(XmlInputPath.ItemSpec))

169using (XmlWriter xmlWriter = XmlWriter.Create(_outputPaths[i].ItemSpec, xslct.OutputSettings)) 289_data[i] = xmlFile[i].ItemSpec; 395_data = xsltFile.ItemSpec; 405_data = xsltCompiledDll.ItemSpec;

41DirectoryInfo sourceDirectory = new DirectoryInfo(SourceDirectory.ItemSpec); 49FileInfo destinationFile = new FileInfo(DestinationFile.ItemSpec);

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

31Assert.Equal("MyResource.fr.resx", t.AssignedFiles[0].ItemSpec); 32Assert.Equal("MyResource.resx", t.CultureNeutralAssignedFiles[0].ItemSpec); 51Assert.Equal("MyResource.fr.resx", t.AssignedFiles[0].ItemSpec); 52Assert.Equal("MyResource.resx", t.CultureNeutralAssignedFiles[0].ItemSpec); 73Assert.Equal("MyResource.fr.resx", t.AssignedFiles[0].ItemSpec); 74Assert.Equal("MyResource.resx", t.CultureNeutralAssignedFiles[0].ItemSpec); 95Assert.Equal("MyResource.fr.resx", t.AssignedFiles[0].ItemSpec); 96Assert.Equal("MyResource.resx", t.CultureNeutralAssignedFiles[0].ItemSpec); 116Assert.Equal("MyResource.resx", t.AssignedFiles[0].ItemSpec); 117Assert.Equal("MyResource.resx", t.CultureNeutralAssignedFiles[0].ItemSpec); 135Assert.Equal("MyResource", t.AssignedFiles[0].ItemSpec); 136Assert.Equal("MyResource", t.CultureNeutralAssignedFiles[0].ItemSpec); 155Assert.Equal("MyResource..resx", t.AssignedFiles[0].ItemSpec); 156Assert.Equal("MyResource..resx", t.CultureNeutralAssignedFiles[0].ItemSpec); 201Assert.Equal($"MyResource.{culture}.resx", t.AssignedFiles[0].ItemSpec); 202Assert.Equal("MyResource.resx", t.CultureNeutralAssignedFiles[0].ItemSpec); 223Assert.Equal($"MyResource.{culture}.resx", t.AssignedFiles[0].ItemSpec); 224Assert.Equal("MyResource.resx", t.CultureNeutralAssignedFiles[0].ItemSpec); 241Assert.Equal($"MyResource.{culture}.resx", t.AssignedFiles[0].ItemSpec); 242Assert.Equal("MyResource.resx", t.CultureNeutralAssignedFiles[0].ItemSpec); 259Assert.Equal($"MyResource.{culture}.resx", t.AssignedFiles[0].ItemSpec); 260Assert.Equal("MyResource.resx", t.CultureNeutralAssignedFiles[0].ItemSpec); 280Assert.Equal("MyResource.fr.resx", t.AssignedFiles[0].ItemSpec); 281Assert.Equal("MyResource.fr.resx", t.CultureNeutralAssignedFiles[0].ItemSpec); 301Assert.Equal("MyResource.fr.resx", t.AssignedFiles[0].ItemSpec); 302Assert.Equal("MyResource.resx", t.CultureNeutralAssignedFiles[0].ItemSpec);

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

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

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

1613Assert.Equal(validOutFile, t.CopiedFiles[0].ItemSpec); 1618Assert.Equal(invalidFile, t.DestinationFiles[0].ItemSpec); 1619Assert.Equal(validOutFile, t.DestinationFiles[1].ItemSpec); 1620Assert.Equal(validOutFile, t.CopiedFiles[0].ItemSpec); 1688Assert.Equal(file, t.DestinationFiles[0].ItemSpec); 1707Assert.Equal(file, t.DestinationFiles[0].ItemSpec); 1759Assert.Equal(filename.ToLowerInvariant(), t.DestinationFiles[0].ItemSpec); 1814Assert.Equal(file, t.DestinationFiles[0].ItemSpec); 1815Assert.Equal(dest2, t.DestinationFiles[1].ItemSpec); 1816Assert.Equal(file, t.CopiedFiles[0].ItemSpec); 1896Assert.Equal(destFile, t.DestinationFiles[0].ItemSpec); 1897Assert.Equal(destFile, t.CopiedFiles[0].ItemSpec); 1957Assert.Equal(destFile, t.DestinationFiles[0].ItemSpec); 1958Assert.Equal(destFile, t.CopiedFiles[0].ItemSpec); 1988using (StreamWriter sw = FileUtilities.OpenWrite(item.ItemSpec, false)) // HIGHCHAR: Test writes in UTF8 without preamble. 2046using (StreamWriter sw = FileUtilities.OpenWrite(item.ItemSpec, false)) // HIGHCHAR: Test writes in UTF8 without preamble. 2583Assert.Equal(destFile, t.DestinationFiles[0].ItemSpec); 2584Assert.Equal(destFile, t.CopiedFiles[0].ItemSpec); 2682Assert.Equal(destFile1, t.DestinationFiles[0].ItemSpec); 2683Assert.Equal(destFile2, t.DestinationFiles[1].ItemSpec); 2684Assert.Equal(destFile1, t.CopiedFiles[0].ItemSpec); 2685Assert.Equal(destFile2, t.CopiedFiles[1].ItemSpec); 2775Assert.Equal(destFile, t.DestinationFiles[0].ItemSpec); 2776Assert.Equal(destFile, t.CopiedFiles[0].ItemSpec); 2840Assert.Equal(destFile, t.DestinationFiles[0].ItemSpec); 2841Assert.Equal(destFile, t.CopiedFiles[0].ItemSpec);

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);

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

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

83downloadFile.DownloadedFile.ItemSpec.ShouldBe(file.FullName); 128downloadFile.DownloadedFile.ItemSpec.ShouldBe(file.FullName); 162downloadFile.DownloadedFile.ItemSpec.ShouldBe(file.FullName);

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

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);

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);

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

34Assert.Equal(FileUtilities.FixFilePath(@"C:\MyProject\File1.txt"), t.InPath[0].ItemSpec); 35Assert.Equal(FileUtilities.FixFilePath(@"C:\SomeoneElsesProject\File2.txt"), t.OutOfPath[0].ItemSpec); 110Assert.Equal(testFile.FullName, t.InPath[0].ItemSpec); 112t.OutOfPath[0].ItemSpec); 132Assert.Equal(testFile.Name, t.InPath[0].ItemSpec); 134t.OutOfPath[0].ItemSpec);

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

435Assert.Equal(winmd, t.References[0].ItemSpec, true); 436Assert.Equal("A.winmd", Path.GetFileName(t.References[0].ItemSpec), true); 445Assert.Equal("E.dll", Path.GetFileName(t.References[4].ItemSpec), true); 454Assert.Equal("A.winmd", Path.GetFileName(t.CopyLocalFiles[0].ItemSpec), true); 463Assert.Equal("E.dll", Path.GetFileName(t.CopyLocalFiles[5].ItemSpec), true); 472Assert.Equal("B.xml", Path.GetFileName(t.CopyLocalFiles[2].ItemSpec)); 557Assert.Equal("A.winmd", Path.GetFileName(t.References[0].ItemSpec), true); 566Assert.Equal("B.winmd", Path.GetFileName(t.References[1].ItemSpec), true); 575Assert.Equal("E.dll", Path.GetFileName(t.References[4].ItemSpec), true); 610string sdkRoot = item.ItemSpec; 635Assert.DoesNotContain(references1, i => i.ItemSpec.Equals(ref2.ItemSpec, StringComparison.InvariantCultureIgnoreCase)); 640string sdkRoot2 = item.ItemSpec; 675engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingReference", t.References[0].ItemSpec.Replace(t.References[0].GetMetadata("SDKRootPath"), String.Empty)); 676engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingReference", t.References[1].ItemSpec.Replace(t.References[1].GetMetadata("SDKRootPath"), String.Empty)); 677engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingReference", t.References[2].ItemSpec.Replace(t.References[2].GetMetadata("SDKRootPath"), String.Empty)); 678engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingReference", t.References[3].ItemSpec.Replace(t.References[3].GetMetadata("SDKRootPath"), String.Empty)); 679engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingReference", t.References[4].ItemSpec.Replace(t.References[4].GetMetadata("SDKRootPath"), String.Empty)); 680engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingReference", t.References[5].ItemSpec.Replace(t.References[5].GetMetadata("SDKRootPath"), String.Empty)); 681engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingReference", t.References[6].ItemSpec.Replace(t.References[6].GetMetadata("SDKRootPath"), String.Empty)); 682engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingReference", t.References[7].ItemSpec.Replace(t.References[7].GetMetadata("SDKRootPath"), String.Empty)); 684Assert.Equal("A.winmd", Path.GetFileName(t.References[0].ItemSpec)); 691Assert.Equal("E.dll", Path.GetFileName(t.References[4].ItemSpec)); 724engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingReference", t.References[0].ItemSpec.Replace(t.References[0].GetMetadata("SDKRootPath"), String.Empty)); 725engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingReference", t.References[1].ItemSpec.Replace(t.References[1].GetMetadata("SDKRootPath"), String.Empty)); 726engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingReference", t.References[2].ItemSpec.Replace(t.References[2].GetMetadata("SDKRootPath"), String.Empty)); 727engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingReference", t.References[3].ItemSpec.Replace(t.References[3].GetMetadata("SDKRootPath"), String.Empty)); 728engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingReference", t.References[4].ItemSpec.Replace(t.References[4].GetMetadata("SDKRootPath"), String.Empty)); 730Assert.Equal("A.dll", Path.GetFileName(t.References[0].ItemSpec), true); 737Assert.Equal("h.dll", Path.GetFileName(t.References[4].ItemSpec), true); 816engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingReference", t.References[0].ItemSpec.Replace(t.References[0].GetMetadata("SDKRootPath"), String.Empty)); 817engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingReference", t.References[1].ItemSpec.Replace(t.References[1].GetMetadata("SDKRootPath"), String.Empty)); 818engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingReference", t.References[2].ItemSpec.Replace(t.References[2].GetMetadata("SDKRootPath"), String.Empty)); 819engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingReference", t.References[3].ItemSpec.Replace(t.References[3].GetMetadata("SDKRootPath"), String.Empty)); 820engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingReference", t.References[4].ItemSpec.Replace(t.References[4].GetMetadata("SDKRootPath"), String.Empty)); 821engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingReference", t.References[5].ItemSpec.Replace(t.References[5].GetMetadata("SDKRootPath"), String.Empty)); 822engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingReference", t.References[6].ItemSpec.Replace(t.References[6].GetMetadata("SDKRootPath"), String.Empty)); 823engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingReference", t.References[7].ItemSpec.Replace(t.References[7].GetMetadata("SDKRootPath"), String.Empty)); 825Assert.True(t.References[0].ItemSpec.IndexOf("x64", StringComparison.OrdinalIgnoreCase) > -1); 826Assert.Equal("A.winmd", Path.GetFileName(t.References[0].ItemSpec)); 835Assert.Equal("E.dll", Path.GetFileName(t.References[4].ItemSpec)); 868engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingReference", t.References[0].ItemSpec.Replace(t.References[0].GetMetadata("SDKRootPath"), String.Empty)); 869engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingReference", t.References[1].ItemSpec.Replace(t.References[1].GetMetadata("SDKRootPath"), String.Empty)); 870engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingReference", t.References[2].ItemSpec.Replace(t.References[2].GetMetadata("SDKRootPath"), String.Empty)); 871engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingReference", t.References[3].ItemSpec.Replace(t.References[3].GetMetadata("SDKRootPath"), String.Empty)); 872engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingReference", t.References[4].ItemSpec.Replace(t.References[4].GetMetadata("SDKRootPath"), String.Empty)); 873engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingReference", t.References[5].ItemSpec.Replace(t.References[5].GetMetadata("SDKRootPath"), String.Empty)); 874engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingReference", t.References[6].ItemSpec.Replace(t.References[6].GetMetadata("SDKRootPath"), String.Empty)); 875engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingReference", t.References[7].ItemSpec.Replace(t.References[7].GetMetadata("SDKRootPath"), String.Empty)); 877Assert.True(t.References[0].ItemSpec.IndexOf("x64", StringComparison.OrdinalIgnoreCase) > -1); 878Assert.Equal("A.winmd", Path.GetFileName(t.References[0].ItemSpec)); 887Assert.Equal("E.dll", Path.GetFileName(t.References[4].ItemSpec)); 919engine.AssertLogDoesntContainMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingReference", t.References[0].ItemSpec.Replace(t.References[0].GetMetadata("SDKRootPath"), String.Empty)); 920engine.AssertLogDoesntContainMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingReference", t.References[1].ItemSpec.Replace(t.References[1].GetMetadata("SDKRootPath"), String.Empty)); 921engine.AssertLogDoesntContainMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingReference", t.References[2].ItemSpec.Replace(t.References[2].GetMetadata("SDKRootPath"), String.Empty)); 922engine.AssertLogDoesntContainMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingReference", t.References[3].ItemSpec.Replace(t.References[3].GetMetadata("SDKRootPath"), String.Empty)); 923engine.AssertLogDoesntContainMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingReference", t.References[4].ItemSpec.Replace(t.References[4].GetMetadata("SDKRootPath"), String.Empty)); 924engine.AssertLogDoesntContainMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingReference", t.References[5].ItemSpec.Replace(t.References[5].GetMetadata("SDKRootPath"), String.Empty)); 925engine.AssertLogDoesntContainMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingReference", t.References[6].ItemSpec.Replace(t.References[6].GetMetadata("SDKRootPath"), String.Empty)); 926engine.AssertLogDoesntContainMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingReference", t.References[7].ItemSpec.Replace(t.References[7].GetMetadata("SDKRootPath"), String.Empty)); 957engine.AssertLogDoesntContainMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingRedistFile", t.RedistFiles[0].ItemSpec.Replace(t.RedistFiles[0].GetMetadata("SDKRootPath"), String.Empty), t.RedistFiles[0].GetMetadata("TargetPath")); 958engine.AssertLogDoesntContainMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingRedistFile", t.RedistFiles[1].ItemSpec.Replace(t.RedistFiles[1].GetMetadata("SDKRootPath"), String.Empty), t.RedistFiles[1].GetMetadata("TargetPath")); 959engine.AssertLogDoesntContainMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingRedistFile", t.RedistFiles[2].ItemSpec.Replace(t.RedistFiles[2].GetMetadata("SDKRootPath"), String.Empty), t.RedistFiles[2].GetMetadata("TargetPath")); 960engine.AssertLogDoesntContainMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingRedistFile", t.RedistFiles[3].ItemSpec.Replace(t.RedistFiles[3].GetMetadata("SDKRootPath"), String.Empty), t.RedistFiles[3].GetMetadata("TargetPath")); 961engine.AssertLogDoesntContainMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingRedistFile", t.RedistFiles[4].ItemSpec.Replace(t.RedistFiles[4].GetMetadata("SDKRootPath"), String.Empty), t.RedistFiles[4].GetMetadata("TargetPath")); 963Assert.Equal("A.dll", Path.GetFileName(t.RedistFiles[0].ItemSpec)); 969Assert.Equal("B.dll", Path.GetFileName(t.RedistFiles[1].ItemSpec), true); 975Assert.Equal("B.PRI", Path.GetFileName(t.RedistFiles[2].ItemSpec), true); 981Assert.Equal("C.dll", Path.GetFileName(t.RedistFiles[3].ItemSpec), true); 987Assert.Equal("D.dll", Path.GetFileName(t.RedistFiles[4].ItemSpec), true); 1018engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingRedistFile", t.RedistFiles[0].ItemSpec.Replace(t.RedistFiles[0].GetMetadata("SDKRootPath"), String.Empty), t.RedistFiles[0].GetMetadata("TargetPath")); 1019engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingRedistFile", t.RedistFiles[1].ItemSpec.Replace(t.RedistFiles[1].GetMetadata("SDKRootPath"), String.Empty), t.RedistFiles[1].GetMetadata("TargetPath")); 1020engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingRedistFile", t.RedistFiles[2].ItemSpec.Replace(t.RedistFiles[2].GetMetadata("SDKRootPath"), String.Empty), t.RedistFiles[2].GetMetadata("TargetPath")); 1021engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingRedistFile", t.RedistFiles[3].ItemSpec.Replace(t.RedistFiles[3].GetMetadata("SDKRootPath"), String.Empty), t.RedistFiles[3].GetMetadata("TargetPath")); 1022engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingRedistFile", t.RedistFiles[4].ItemSpec.Replace(t.RedistFiles[4].GetMetadata("SDKRootPath"), String.Empty), t.RedistFiles[4].GetMetadata("TargetPath")); 1049Assert.True(t.RedistFiles[0].ItemSpec.IndexOf("x64", StringComparison.OrdinalIgnoreCase) > -1); 1050engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingRedistFile", t.RedistFiles[0].ItemSpec.Replace(t.RedistFiles[0].GetMetadata("SDKRootPath"), String.Empty), t.RedistFiles[0].GetMetadata("TargetPath")); 1051engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingRedistFile", t.RedistFiles[1].ItemSpec.Replace(t.RedistFiles[1].GetMetadata("SDKRootPath"), String.Empty), t.RedistFiles[1].GetMetadata("TargetPath")); 1052engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingRedistFile", t.RedistFiles[2].ItemSpec.Replace(t.RedistFiles[2].GetMetadata("SDKRootPath"), String.Empty), t.RedistFiles[2].GetMetadata("TargetPath")); 1053engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingRedistFile", t.RedistFiles[3].ItemSpec.Replace(t.RedistFiles[3].GetMetadata("SDKRootPath"), String.Empty), t.RedistFiles[3].GetMetadata("TargetPath")); 1054engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingRedistFile", t.RedistFiles[4].ItemSpec.Replace(t.RedistFiles[4].GetMetadata("SDKRootPath"), String.Empty), t.RedistFiles[4].GetMetadata("TargetPath")); 1081Assert.True(t.RedistFiles[0].ItemSpec.IndexOf("x64", StringComparison.OrdinalIgnoreCase) > -1); 1082engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingRedistFile", t.RedistFiles[0].ItemSpec.Replace(t.RedistFiles[0].GetMetadata("SDKRootPath"), String.Empty), t.RedistFiles[0].GetMetadata("TargetPath")); 1083engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingRedistFile", t.RedistFiles[1].ItemSpec.Replace(t.RedistFiles[1].GetMetadata("SDKRootPath"), String.Empty), t.RedistFiles[1].GetMetadata("TargetPath")); 1084engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingRedistFile", t.RedistFiles[2].ItemSpec.Replace(t.RedistFiles[2].GetMetadata("SDKRootPath"), String.Empty), t.RedistFiles[2].GetMetadata("TargetPath")); 1085engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingRedistFile", t.RedistFiles[3].ItemSpec.Replace(t.RedistFiles[3].GetMetadata("SDKRootPath"), String.Empty), t.RedistFiles[3].GetMetadata("TargetPath")); 1086engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingRedistFile", t.RedistFiles[4].ItemSpec.Replace(t.RedistFiles[4].GetMetadata("SDKRootPath"), String.Empty), t.RedistFiles[4].GetMetadata("TargetPath")); 1369Assert.Equal("A.dll", Path.GetFileName(t.RedistFiles[0].ItemSpec), true); 1375Assert.Equal("B.dll", Path.GetFileName(t.RedistFiles[1].ItemSpec), true); 1381Assert.Equal("B.dll", Path.GetFileName(t.RedistFiles[2].ItemSpec), true); 1387Assert.Equal("B.pri", Path.GetFileName(t.RedistFiles[3].ItemSpec), true); 1393Assert.Equal("B.PRI", Path.GetFileName(t.RedistFiles[4].ItemSpec), true); 1399Assert.Equal("C.dll", Path.GetFileName(t.RedistFiles[5].ItemSpec), true); 1405Assert.Equal("D.dll", Path.GetFileName(t.RedistFiles[6].ItemSpec), true);

43Assert.Equal(dir, t.DirectoriesCreated[0].ItemSpec); 50Assert.Equal(dir, t.DirectoriesCreated[0].ItemSpec); 94Assert.Equal(dir2, t.DirectoriesCreated[1].ItemSpec); 102Assert.Equal(dir2, t.DirectoriesCreated[2].ItemSpec); 105Assert.Equal(dir, t.DirectoriesCreated[0].ItemSpec); 146Assert.Equal(dir, t.DirectoriesCreated[0].ItemSpec); 157Assert.Equal(dir, t.DirectoriesCreated[0].ItemSpec); 214Assert.Equal(dir, t.DirectoriesCreated[0].ItemSpec);

51Assert.Equal(destinationFile, t.DestinationFiles[0].ItemSpec); 97Assert.Equal(destinationFile, t.DestinationFiles[0].ItemSpec); 145Assert.Equal(destinationFile, t.DestinationFiles[0].ItemSpec); 459Assert.Equal(validOutFile, t.MovedFiles[0].ItemSpec); 464Assert.Equal(invalidFile, t.DestinationFiles[0].ItemSpec); 465Assert.Equal(validOutFile, t.DestinationFiles[1].ItemSpec); 466Assert.Equal(validOutFile, t.MovedFiles[0].ItemSpec); 618Assert.Equal(filename.ToLowerInvariant(), t.DestinationFiles[0].ItemSpec); 662Assert.Equal(file, t.DestinationFiles[0].ItemSpec); 663Assert.Equal(dest2, t.DestinationFiles[1].ItemSpec); 665Assert.Equal(file, t.MovedFiles[0].ItemSpec); 715Assert.Equal(destFile, t.DestinationFiles[0].ItemSpec); 716Assert.Equal(destFile, t.MovedFiles[0].ItemSpec);

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);

47Assert.Equal("Line1", r.Lines[0].ItemSpec); 56Assert.Equal("Line1", r.Lines[0].ItemSpec); 57Assert.Equal("Line2", r.Lines[1].ItemSpec); 58Assert.Equal("Line3", r.Lines[2].ItemSpec); 94Assert.Equal("Line1_%3b_", r.Lines[0].ItemSpec); 103Assert.Equal("Line1_%3b_", r.Lines[0].ItemSpec); 104Assert.Equal("Line2", r.Lines[1].ItemSpec); 105Assert.Equal("Line3", r.Lines[2].ItemSpec); 139Assert.Equal("My special character is \u00C3", r.Lines[0].ItemSpec); 199Assert.Equal("Line1", r.Lines[0].ItemSpec); 200Assert.Equal("Line2", r.Lines[1].ItemSpec); 201Assert.Equal("Line3", r.Lines[2].ItemSpec);

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

28Assert.Equal("MyFile.txt", t.Filtered[0].ItemSpec); 46Assert.Equal("MyFile.txt", t.Filtered[0].ItemSpec); 71Assert.Equal("MyFile2.txt", t.Filtered[0].ItemSpec); 72Assert.Equal("MyFile1.txt", t.Filtered[1].ItemSpec); 73Assert.Equal("MyFile3.txt", t.Filtered[2].ItemSpec); 97Assert.Equal("MyFile2.txt", t.Filtered[0].ItemSpec); 98Assert.Equal("MyFile1.txt", t.Filtered[1].ItemSpec); 99Assert.Equal("MyFile3.txt", t.Filtered[2].ItemSpec); 116Assert.Equal("MyFile1.txt", t.Filtered[0].ItemSpec); 117Assert.Equal("MyFile2.txt", t.Filtered[1].ItemSpec); 135Assert.Equal("MyFile.txt", t.Filtered[0].ItemSpec);

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

450Assert.Equal(_sdkPath, t.ResolvedSDKReferences[0].ItemSpec); 512Assert.Equal(testDirectory, t.ResolvedSDKReferences[0].ItemSpec); 566string errorMessage = t.Log.FormatResourceString("ResolveSDKReference.SDKReferenceIncorrectFormat", referenceInclude.ItemSpec); 671string errorMessage = t.Log.FormatResourceString("ResolveSDKReference.Prefer32BitNotSupportedWithNeutralProject", item.ItemSpec); 894string errorMessage = t.Log.FormatResourceString("ResolveSDKReference.Prefer32BitNotSupportedWithNeutralProject", item.ItemSpec); 1095Assert.Equal(_sdkPath, t.ResolvedSDKReferences[0].ItemSpec); 1104Assert.Equal(item.ItemSpec, t.ResolvedSDKReferences[0].GetMetadata("OriginalItemSpec"), true); 1133Assert.Equal(_sdkPath, t.ResolvedSDKReferences[0].ItemSpec); 1142Assert.Equal(item.ItemSpec, t.ResolvedSDKReferences[0].GetMetadata("OriginalItemSpec"), true); 1174Assert.Equal(_sdkPath, t.ResolvedSDKReferences[0].ItemSpec); 1183Assert.Equal(item.ItemSpec, t.ResolvedSDKReferences[0].GetMetadata("OriginalItemSpec"), true); 1212Assert.Equal(_sdkPath, t.ResolvedSDKReferences[0].ItemSpec); 1219Assert.Equal(item.ItemSpec, t.ResolvedSDKReferences[0].GetMetadata("OriginalItemSpec"), true); 1251Assert.Equal(_sdkPath, t.ResolvedSDKReferences[0].ItemSpec); 1260Assert.Equal(item.ItemSpec, t.ResolvedSDKReferences[0].GetMetadata("OriginalItemSpec"), true); 1285Assert.Equal(_sdkPath, t.ResolvedSDKReferences[0].ItemSpec); 1292Assert.Equal(item.ItemSpec, t.ResolvedSDKReferences[0].GetMetadata("OriginalItemSpec"), true); 1356Assert.Equal(_sdkPath, t.ResolvedSDKReferences[0].ItemSpec); 1365Assert.Equal(item.ItemSpec, t.ResolvedSDKReferences[0].GetMetadata("OriginalItemSpec"), true); 1423Assert.Equal(_sdkPath, t.ResolvedSDKReferences[0].ItemSpec); 1531Assert.Equal(testDirectory, t.ResolvedSDKReferences[0].ItemSpec); 1532Assert.Equal(goodSDKLocation, t.ResolvedSDKReferences[1].ItemSpec); 1758Assert.Equal(testDirectory, t.ResolvedSDKReferences[0].ItemSpec); 1775Assert.Equal(item.ItemSpec, t.ResolvedSDKReferences[0].GetMetadata("OriginalItemSpec"), true); 1857Assert.Equal(testDirectory, t.ResolvedSDKReferences[0].ItemSpec); 1869Assert.Equal(item.ItemSpec, t.ResolvedSDKReferences[0].GetMetadata("OriginalItemSpec"), true); 1936Assert.Equal(testDirectory, t.ResolvedSDKReferences[0].ItemSpec); 1945Assert.Equal(item.ItemSpec, t.ResolvedSDKReferences[0].GetMetadata("OriginalItemSpec"), true); 2007Assert.Equal(testDirectory, t.ResolvedSDKReferences[0].ItemSpec); 2015Assert.Equal(item.ItemSpec, t.ResolvedSDKReferences[0].GetMetadata("OriginalItemSpec"), true); 2071Assert.Equal(testDirectory, t.ResolvedSDKReferences[0].ItemSpec); 2081Assert.Equal(item.ItemSpec, t.ResolvedSDKReferences[0].GetMetadata("OriginalItemSpec"), true); 2147Assert.Equal(testDirectory, t.ResolvedSDKReferences[0].ItemSpec); 2156Assert.Equal(item.ItemSpec, t.ResolvedSDKReferences[0].GetMetadata("OriginalItemSpec"), true); 2215Assert.Equal(testDirectory, t.ResolvedSDKReferences[0].ItemSpec); 2224Assert.Equal(item.ItemSpec, t.ResolvedSDKReferences[0].GetMetadata("OriginalItemSpec"), true); 2285Assert.Equal(testDirectory, t.ResolvedSDKReferences[0].ItemSpec); 2294Assert.Equal(item.ItemSpec, t.ResolvedSDKReferences[0].GetMetadata("OriginalItemSpec"), true); 2499Assert.Equal(testDirectory, t.ResolvedSDKReferences[0].ItemSpec); 2508Assert.Equal(item.ItemSpec, t.ResolvedSDKReferences[0].GetMetadata("OriginalItemSpec"), true); 2573Assert.Equal(testDirectory, t.ResolvedSDKReferences[0].ItemSpec); 2640Assert.Equal(testDirectory, t.ResolvedSDKReferences[0].ItemSpec); 2704Assert.Equal(testDirectory, t.ResolvedSDKReferences[0].ItemSpec); 2772Assert.Equal(testDirectory, t.ResolvedSDKReferences[0].ItemSpec); 2869Assert.Equal(testDirectory, t.ResolvedSDKReferences[0].ItemSpec); 2870Assert.Equal(testDirectory2, t.ResolvedSDKReferences[1].ItemSpec); 2871Assert.Equal(testDirectory3, t.ResolvedSDKReferences[2].ItemSpec); 2967Assert.Equal(testDirectory, t.ResolvedSDKReferences[0].ItemSpec); 2968Assert.Equal(testDirectory2, t.ResolvedSDKReferences[1].ItemSpec); 2969Assert.Equal(testDirectory3, t.ResolvedSDKReferences[2].ItemSpec); 3079Assert.Equal(testDirectory, t.ResolvedSDKReferences[0].ItemSpec); 3080Assert.Equal(testDirectory2, t.ResolvedSDKReferences[1].ItemSpec); 3081Assert.Equal(testDirectory3, t.ResolvedSDKReferences[2].ItemSpec); 3082Assert.Equal(testDirectory4, t.ResolvedSDKReferences[3].ItemSpec); 3178Assert.Equal(testDirectory, t.ResolvedSDKReferences[0].ItemSpec); 3179Assert.Equal(testDirectory2, t.ResolvedSDKReferences[1].ItemSpec); 3180Assert.Equal(testDirectory3, t.ResolvedSDKReferences[2].ItemSpec); 3254Assert.Equal(testDirectory, t.ResolvedSDKReferences[0].ItemSpec); 3329Assert.Equal(testDirectory, t.ResolvedSDKReferences[0].ItemSpec); 3338Assert.Equal(item.ItemSpec, t.ResolvedSDKReferences[0].GetMetadata("OriginalItemSpec"), true); 3473Assert.Equal(testDirectory, t.ResolvedSDKReferences[0].ItemSpec); 3482Assert.Equal(item.ItemSpec, t.ResolvedSDKReferences[0].GetMetadata("OriginalItemSpec"), true); 3609Assert.Equal(testDirectory, t.ResolvedSDKReferences[0].ItemSpec); 3618Assert.Equal(item.ItemSpec, t.ResolvedSDKReferences[0].GetMetadata("OriginalItemSpec"), true);

72string resourcesFile = t.OutputResources[0].ItemSpec; 74resourcesFile = t.FilesWritten[0].ItemSpec; 90File.Delete(t.Sources[0].ItemSpec); 93if (File.Exists(item.ItemSpec)) 95File.Delete(item.ItemSpec); 138File.Delete(item.ItemSpec); 160string resourcesFile = t.OutputResources[0].ItemSpec; 162resourcesFile = t.FilesWritten[0].ItemSpec; 173File.Delete(t.Sources[0].ItemSpec); 176if (File.Exists(item.ItemSpec)) 178File.Delete(item.ItemSpec); 209resourcesFile = t.OutputResources[0].ItemSpec; 211Assert.Equal(t.FilesWritten[0].ItemSpec, resourcesFile); 248Assert.Equal(".resx", Path.GetExtension(t.FilesWritten[0].ItemSpec)); 255Assert.Equal(".txt", Path.GetExtension(t2a.FilesWritten[0].ItemSpec)); 259t2b.Sources = new ITaskItem[] { new TaskItem(t2a.FilesWritten[0].ItemSpec) }; 262Assert.Equal(".resx", Path.GetExtension(t2b.FilesWritten[0].ItemSpec)); 265Assert.Equal(Utilities.ReadFileContent(t.OutputResources[0].ItemSpec), 266Utilities.ReadFileContent(t2b.OutputResources[0].ItemSpec)); 267Utilities.AssertLogContainsResource(t2b, "GenerateResource.ProcessingFile", t2b.Sources[0].ItemSpec, t2b.OutputResources[0].ItemSpec); 268Utilities.AssertLogContainsResource(t2b, "GenerateResource.ReadResourceMessage", 4, t2b.Sources[0].ItemSpec); 272File.Delete(t.OutputResources[0].ItemSpec); 273File.Delete(t2a.OutputResources[0].ItemSpec); 276File.Delete(item.ItemSpec); 300resourcesFile = t.FilesWritten[0].ItemSpec; 303Utilities.AssertLogContainsResource(t, "GenerateResource.ProcessingFile", t.Sources[0].ItemSpec, outputFile); 304Utilities.AssertLogContainsResource(t, "GenerateResource.ReadResourceMessage", 4, t.Sources[0].ItemSpec); 307File.Delete(t.Sources[0].ItemSpec); 310File.Delete(item.ItemSpec); 332var resourceOutput = t.OutputResources[0].ItemSpec; 334Path.GetExtension(t.FilesWritten[0].ItemSpec).ShouldBe(".resources"); 347Utilities.AssertLogContainsResource(t, "GenerateResource.OutputDoesntExist", t.OutputResources[0].ItemSpec); 360File.GetLastAccessTime(t2.OutputResources[0].ItemSpec).ShouldBe(DateTime.Now, TimeSpan.FromSeconds(5)); 362Utilities.AssertLogContainsResource(t2, "GenerateResource.InputNewer", t2.Sources[0].ItemSpec, t2.OutputResources[0].ItemSpec); 377Utilities.AssertLogContainsResource(t, "GenerateResource.OutputDoesntExist", t.OutputResources[0].ItemSpec); 388Utilities.AssertLogContainsResource(t2, "GenerateResource.ResourceNotFound", t2.Sources[0].ItemSpec); 410Path.GetExtension(t.OutputResources[0].ItemSpec).ShouldBe(".resources"); 411Path.GetExtension(t.FilesWritten[0].ItemSpec).ShouldBe(".resources"); 419DateTime firstWriteTime = File.GetLastWriteTime(t.OutputResources[0].ItemSpec); 425File.GetLastWriteTime(t2.OutputResources[0].ItemSpec).ShouldBeGreaterThan(firstWriteTime); 432t2.OutputResources[0].ItemSpec); 437File.Delete(t.Sources[0].ItemSpec); 441if (File.Exists(item.ItemSpec)) 443File.Delete(item.ItemSpec); 463Utilities.AssertLogContainsResource(t1, "GenerateResource.OutputDoesntExist", t1.OutputResources[0].ItemSpec); 481File.Delete(output[0].ItemSpec); 485Utilities.AssertLogContainsResource(t3, "GenerateResource.ProcessingFile", sources[0].ItemSpec, output[0].ItemSpec); 492Utilities.AssertLogContainsResource(t4, "GenerateResource.OutputDoesntExist", t4.OutputResources[0].ItemSpec); 566File.Delete(t.Sources[0].ItemSpec); 571File.Delete(item.ItemSpec); 604File.Delete(t.Sources[0].ItemSpec); 608File.Delete(item.ItemSpec); 631Path.GetExtension(t.OutputResources[0].ItemSpec).ShouldBe(".resources"); 632Path.GetExtension(t.FilesWritten[0].ItemSpec).ShouldBe(".resources"); 655File.Delete(t.Sources[0].ItemSpec); 659if (File.Exists(item.ItemSpec)) 661File.Delete(item.ItemSpec); 687DateTime firstOutputCreationTime = File.GetLastWriteTime(createResources.OutputResources[0].ItemSpec); 688DateTime secondOutputCreationTime = File.GetLastWriteTime(createResources.OutputResources[1].ItemSpec); 692t2.StateFile = new TaskItem(createResources.StateFile.ItemSpec); 712File.GetLastWriteTime(t2.OutputResources[0].ItemSpec).ShouldBeGreaterThan(firstOutputCreationTime); 713File.GetLastWriteTime(t2.OutputResources[1].ItemSpec).ShouldBe(secondOutputCreationTime); 716t2.OutputResources[0].ItemSpec.ShouldBe(createResources.OutputResources[0].ItemSpec); 717t2.OutputResources[1].ItemSpec.ShouldBe(createResources.OutputResources[1].ItemSpec); 718t2.FilesWritten[0].ItemSpec.ShouldBe(createResources.FilesWritten[0].ItemSpec); 719t2.FilesWritten[1].ItemSpec.ShouldBe(createResources.FilesWritten[1].ItemSpec); 721Utilities.AssertLogContainsResource(t2, "GenerateResource.InputNewer", firstResx, t2.OutputResources[0].ItemSpec); 745string resourcesFile = t.OutputResources[0].ItemSpec; 747resourcesFile = t.FilesWritten[0].ItemSpec; 752DateTime time = File.GetLastWriteTime(t.OutputResources[0].ItemSpec); 762Assert.True(time.Equals(File.GetLastWriteTime(t2.OutputResources[0].ItemSpec))); 767File.Delete(t.Sources[0].ItemSpec); 771if (File.Exists(item.ItemSpec)) 773File.Delete(item.ItemSpec); 803Assert.Equal(t.OutputResources[0].ItemSpec, resourcesFile1); 804Assert.Equal(t.FilesWritten[0].ItemSpec, resourcesFile1); 805Assert.Equal(t.OutputResources[1].ItemSpec, resourcesFile2); 806Assert.Equal(t.FilesWritten[1].ItemSpec, resourcesFile2); 815DateTime time = File.GetLastWriteTime(t.OutputResources[0].ItemSpec); 816DateTime time2 = File.GetLastWriteTime(t.OutputResources[1].ItemSpec); 822Assert.Equal(t2.OutputResources[0].ItemSpec, resourcesFile1); 823Assert.Equal(t2.FilesWritten[0].ItemSpec, resourcesFile1); 824Assert.Equal(t2.OutputResources[1].ItemSpec, resourcesFile2); 825Assert.Equal(t2.FilesWritten[1].ItemSpec, resourcesFile2); 829Assert.True(time.Equals(File.GetLastWriteTime(t2.OutputResources[0].ItemSpec))); 830Assert.True(time2.Equals(File.GetLastWriteTime(t2.OutputResources[1].ItemSpec))); 885DateTime firstWriteTime = File.GetLastWriteTime(initialCreator.OutputResources[0].ItemSpec); 895File.GetLastWriteTime(incrementalUpToDate.OutputResources[0].ItemSpec).ShouldBe(firstWriteTime); 915File.GetLastWriteTime(incrementalOutOfDate.OutputResources[0].ItemSpec).ShouldBeGreaterThan(firstWriteTime); 917resourcesFile = incrementalOutOfDate.OutputResources[0].ItemSpec; 919Utilities.AssertLogContainsResource(incrementalOutOfDate, "GenerateResource.InputNewer", localSystemDll, incrementalOutOfDate.OutputResources[0].ItemSpec); 962if (!File.Exists(file.ItemSpec)) 964File.WriteAllText(file.ItemSpec, ""); 984File.SetLastWriteTime(additionalInputs[1].ItemSpec, newTime); 991Utilities.AssertLogContainsResource(t3, "GenerateResource.InputNewer", additionalInputs[1].ItemSpec, t3.OutputResources[0].ItemSpec); 992resourcesFile = t3.OutputResources[0].ItemSpec; 1006if (additionalInputs?[0] != null && File.Exists(additionalInputs[0].ItemSpec)) 1008File.Delete(additionalInputs[0].ItemSpec); 1011if (additionalInputs?[1] != null && File.Exists(additionalInputs[1].ItemSpec)) 1013File.Delete(additionalInputs[1].ItemSpec); 1038string resourcesFile = t.OutputResources[0].ItemSpec; 1045File.Delete(t.Sources[0].ItemSpec); 1048File.Delete(item.ItemSpec); 1069Assert.Equal(".resx", Path.GetExtension(t.FilesWritten[0].ItemSpec)); 1073t2a.Sources = new ITaskItem[] { new TaskItem(t.FilesWritten[0].ItemSpec) }; 1074t2a.OutputResources = new ITaskItem[] { new TaskItem(Path.ChangeExtension(t.FilesWritten[0].ItemSpec, ".resources")) }; 1076Assert.Equal(".resources", Path.GetExtension(t2a.FilesWritten[0].ItemSpec)); 1080t2b.Sources = new ITaskItem[] { new TaskItem(t2a.FilesWritten[0].ItemSpec) }; 1082File.Delete(t2b.OutputResources[0].ItemSpec); 1084Assert.Equal(".resx", Path.GetExtension(t2b.FilesWritten[0].ItemSpec)); 1087Assert.Equal(Utilities.ReadFileContent(t.OutputResources[0].ItemSpec), 1088Utilities.ReadFileContent(t2b.OutputResources[0].ItemSpec)); 1092File.Delete(t.OutputResources[0].ItemSpec); 1093File.Delete(t2a.OutputResources[0].ItemSpec); 1096File.Delete(item.ItemSpec); 1119string resourcesFile = t.OutputResources[0].ItemSpec; 1130resourcesFile = t2.FilesWritten[0].ItemSpec; 1136File.Delete(t.Sources[0].ItemSpec); 1139File.Delete(item.ItemSpec); 1142File.Delete(t2.Sources[0].ItemSpec); 1145File.Delete(item.ItemSpec); 1165string resourcesFile = t.OutputResources[0].ItemSpec; 1167string stronglyTypedClassName = Path.GetFileNameWithoutExtension(t.OutputResources[0].ItemSpec); 1170resourcesFile = t.FilesWritten[0].ItemSpec; 1174string stronglyTypedFileName = Path.ChangeExtension(t.Sources[0].ItemSpec, ".cs"); 1175Assert.Equal(t.FilesWritten[2].ItemSpec, stronglyTypedFileName); 1198File.Delete(t.Sources[0].ItemSpec); 1202if (File.Exists(item.ItemSpec)) 1204File.Delete(item.ItemSpec); 1228string resourcesFile = t.OutputResources[0].ItemSpec; 1230string stronglyTypedClassName = Path.GetFileNameWithoutExtension(t.OutputResources[0].ItemSpec); 1233resourcesFile = t.FilesWritten[0].ItemSpec; 1238string stronglyTypedFileName = Path.ChangeExtension(t.Sources[0].ItemSpec, ".cs"); 1239Assert.Equal(t.FilesWritten[2].ItemSpec, stronglyTypedFileName); 1267Assert.Equal(t2.OutputResources[0].ItemSpec, resourcesFile); 1268Assert.Equal(t2.FilesWritten[0].ItemSpec, resourcesFile); 1271Assert.Equal(t2.FilesWritten[2].ItemSpec, Path.ChangeExtension(t2.Sources[0].ItemSpec, ".cs")); 1276File.Delete(t.Sources[0].ItemSpec); 1280if (File.Exists(item.ItemSpec)) 1282File.Delete(item.ItemSpec); 1287if (File.Exists(item.ItemSpec)) 1289File.Delete(item.ItemSpec); 1323resourcesFile = t.OutputResources[0].ItemSpec; 1326Assert.Equal(t.FilesWritten[2].ItemSpec, strFile); 1354Assert.Equal(t.OutputResources[0].ItemSpec, resourcesFile); 1356Assert.Equal(t.FilesWritten[2].ItemSpec, strFile); 1414resourcesFile = t.OutputResources[0].ItemSpec; 1417Assert.Equal(".resources", Path.GetExtension(t.FilesWritten[0].ItemSpec)); 1421Assert.Equal(t.FilesWritten[1].ItemSpec, strFile); 1426Utilities.AssertLogContainsResource(t, "GenerateResource.ProcessingFile", txtFile, t.OutputResources[0].ItemSpec); 1474string stronglyTypedFileName = Path.ChangeExtension(t.Sources[0].ItemSpec, ".vb"); 1475Assert.Equal(t.FilesWritten[2].ItemSpec, stronglyTypedFileName); 1477string resourcesFile = t.OutputResources[0].ItemSpec; 1479resourcesFile = t.FilesWritten[0].ItemSpec; 1505File.Delete(t.Sources[0].ItemSpec); 1509if (File.Exists(item.ItemSpec)) 1511File.Delete(item.ItemSpec); 1533string resourcesFile = t.OutputResources[0].ItemSpec; 1535resourcesFile = t.FilesWritten[0].ItemSpec; 1541string STRfile = Path.ChangeExtension(t.Sources[0].ItemSpec, ".cs"); 1546Assert.Equal(t.StronglyTypedClassName, Path.GetFileNameWithoutExtension(t.OutputResources[0].ItemSpec)); 1558File.Delete(t.Sources[0].ItemSpec); 1562if (File.Exists(item.ItemSpec)) 1564File.Delete(item.ItemSpec); 1591string resourcesFile = t.OutputResources[0].ItemSpec; 1593resourcesFile = t.FilesWritten[0].ItemSpec; 1599string STRfile = Path.ChangeExtension(t.Sources[0].ItemSpec, ".cs"); 1604Assert.Equal(t.StronglyTypedClassName, Path.GetFileNameWithoutExtension(t.OutputResources[0].ItemSpec)); 1628FileUtilities.DeleteNoThrow(item.ItemSpec); 1716File.Delete(t.Sources[0].ItemSpec); 1719File.Delete(item.ItemSpec); 1735File.Delete(t.Sources[0].ItemSpec); 1738File.Delete(item.ItemSpec); 1787Assert.Equal(t.OutputResources[0].ItemSpec, resourcesFile2); 1789Assert.Equal(t.FilesWritten[0].ItemSpec, resourcesFile2); 1866Assert.Equal(t.OutputResources[0].ItemSpec, resourcesFile2); 1868Assert.Equal(t.FilesWritten[0].ItemSpec, resourcesFile2); 1920File.Delete(t.Sources[0].ItemSpec); 1923File.Delete(item.ItemSpec); 1947File.Delete(t.Sources[0].ItemSpec); 1951File.Delete(item.ItemSpec); 1974resourcesFile = t.OutputResources[0].ItemSpec; 1976Assert.Equal(t.FilesWritten[0].ItemSpec, t.OutputResources[0].ItemSpec); 2062File.Delete(t.Sources[0].ItemSpec); 2065File.Delete(item.ItemSpec); 2118File.Delete(t.Sources[0].ItemSpec); 2122File.Delete(item.ItemSpec); 2202Assert.Equal("MyAlternateResource.resources", t.OutputResources[0].ItemSpec); 2208File.Delete(t.Sources[0].ItemSpec); 2211File.Delete(item.ItemSpec); 2232Assert.Equal(resourcesFile, t.OutputResources[0].ItemSpec); 2238File.Delete(t.Sources[0].ItemSpec); 2241File.Delete(item.ItemSpec); 2265string outputFile = Path.ChangeExtension(t.Sources[i].ItemSpec, ".resources"); 2266Assert.Equal(outputFile, t.OutputResources[i].ItemSpec); 2272File.Delete(item.ItemSpec); 2277File.Delete(item.ItemSpec); 2305Assert.Equal(t.FilesWritten[i].ItemSpec, t.OutputResources[i].ItemSpec); 2306Assert.True(File.Exists(t.FilesWritten[i].ItemSpec)); 2312File.Delete(t.StateFile.ItemSpec); 2315File.Delete(item.ItemSpec); 2319File.Delete(item.ItemSpec); 2342File.Delete(Path.ChangeExtension(taskItem.ItemSpec, ".resources")); 2351string outputFile = Path.ChangeExtension(t.Sources[0].ItemSpec, ".resources"); 2352Assert.Equal(outputFile, t.OutputResources[0].ItemSpec); 2353Assert.True(File.Exists(t.OutputResources[0].ItemSpec)); 2354outputFile = Path.ChangeExtension(t.Sources[1].ItemSpec, ".resources"); 2355Assert.Equal(outputFile, t.OutputResources[1].ItemSpec); 2356Assert.True(File.Exists(t.OutputResources[1].ItemSpec)); 2358outputFile = Path.ChangeExtension(t.Sources[2].ItemSpec, ".resources"); 2361outputFile = Path.ChangeExtension(t.Sources[3].ItemSpec, ".resources"); 2362Assert.Equal(outputFile, t.OutputResources[2].ItemSpec); 2363Assert.True(File.Exists(t.OutputResources[2].ItemSpec)); 2366Assert.Equal(t.FilesWritten[0].ItemSpec, Path.ChangeExtension(t.Sources[0].ItemSpec, ".resources")); 2367Assert.Equal(t.FilesWritten[1].ItemSpec, Path.ChangeExtension(t.Sources[1].ItemSpec, ".resources")); 2379Assert.Equal(t.FilesWritten[2].ItemSpec, Path.ChangeExtension(t.Sources[3].ItemSpec, ".resources")); 2393File.Delete(item.ItemSpec); 2397if (File.Exists(item.ItemSpec)) 2399File.Delete(item.ItemSpec); 2427Utilities.AssertLogContainsResource(t, "GenerateResource.ProcessingFile", textFile, t.OutputResources[0].ItemSpec); 2439File.Delete(t.Sources[0].ItemSpec); 2443if (File.Exists(item.ItemSpec)) 2445File.Delete(item.ItemSpec); 2464File.Delete(Path.ChangeExtension(t.Sources[0].ItemSpec, ".cs")); 2469Utilities.AssertLogContainsResource(t, "GenerateResource.ProcessingFile", textFile, t.OutputResources[0].ItemSpec); 2473Assert.Equal(t.StronglyTypedFileName, Path.ChangeExtension(t.Sources[0].ItemSpec, ".cs")); 2484File.Delete(t.Sources[0].ItemSpec); 2489if (File.Exists(item.ItemSpec)) 2491File.Delete(item.ItemSpec); 2525if (item.ItemSpec != null) 2527File.Delete(item.ItemSpec); 2587Assert.Equal(t.OutputResources[0].ItemSpec, resourcesFile); 2616File.SetAttributes(t.StateFile.ItemSpec, FileAttributes.ReadOnly); 2627File.Delete(t.Sources[0].ItemSpec); 2628File.SetAttributes(t.StateFile.ItemSpec, FileAttributes.Normal); 2633if (item.ItemSpec != null) 2635File.Delete(item.ItemSpec); 2662File.Delete(t.Sources[0].ItemSpec); 2667if (item.ItemSpec != null) 2669File.Delete(item.ItemSpec); 2694File.Delete(t.Sources[0].ItemSpec); 2699if (item.ItemSpec != null) 2701File.Delete(item.ItemSpec); 2726File.Delete(t.Sources[0].ItemSpec); 2731if (item.ItemSpec != null) 2733File.Delete(item.ItemSpec); 2758File.Delete(t.Sources[0].ItemSpec); 2763if (item.ItemSpec != null) 2765File.Delete(item.ItemSpec); 3629string resourcesFile = t.OutputResources[0].ItemSpec; 3631resourcesFile = t.FilesWritten[0].ItemSpec; 3651File.Delete(t.Sources[0].ItemSpec); 3654if (File.Exists(item.ItemSpec)) 3656File.Delete(item.ItemSpec); 3686string outputResourceFile = task.OutputResources[0].ItemSpec; 3687task.OutputResources[0].ItemSpec.ShouldBe(task.FilesWritten[0].ItemSpec); 3694string resourcesFile = t.OutputResources[0].ItemSpec; 3703resourcesFile = t.OutputResources[0].ItemSpec; 3826Assert.True(File.Exists(t.StateFile.ItemSpec)); // "State file should exist" 3833if (t.StateFile.ItemSpec.Equals(t.FilesWritten[i].ItemSpec)) 3865return t.OutputResources[0].ItemSpec; 3885File.GetLastWriteTime(t.OutputResources[0].ItemSpec).ShouldBeGreaterThanOrEqualTo(File.GetLastWriteTime(t.Sources[0].ItemSpec), $"we're talking here about {t.OutputResources[0].ItemSpec} and {t.Sources[0].ItemSpec}"); 4235string resourcesFile = t.OutputResources[0].ItemSpec; 4238Assert.Equal(Path.GetFileNameWithoutExtension(textFile), Path.GetFileNameWithoutExtension(t.OutputResources[0].ItemSpec)); 4241string stronglyTypedClassName = Path.GetFileNameWithoutExtension(t.OutputResources[0].ItemSpec); 4248resourcesFile = t.FilesWritten[0].ItemSpec; 4254Assert.Equal(Path.ChangeExtension(t.Sources[0].ItemSpec, codeFileExtension), t.StronglyTypedFileName); 4255Assert.Equal(t.FilesWritten[2].ItemSpec, t.StronglyTypedFileName); 4295File.Delete(t.Sources[0].ItemSpec); 4299if (File.Exists(item.ItemSpec)) 4301File.Delete(item.ItemSpec);

90Assert.Equal(file, task.OutputFile.ItemSpec); 93File.Delete(task.OutputFile.ItemSpec); 115Assert.Equal(expectedFile, task.OutputFile.ItemSpec); 135Assert.Equal(file.ItemSpec, task.OutputFile.ItemSpec); 136Assert.True(File.Exists(task.OutputFile.ItemSpec)); 159Assert.Equal(fileName, task.OutputFile.ItemSpec); 184Assert.Equal(file, task.OutputFile.ItemSpec); 330string content = File.ReadAllText(task.OutputFile.ItemSpec); 356string content = File.ReadAllText(task.OutputFile.ItemSpec); 381Assert.True(File.Exists(task.OutputFile.ItemSpec)); 382Assert.Equal(Path.GetTempPath(), task.OutputFile.ItemSpec.Substring(0, Path.GetTempPath().Length)); 383Assert.Equal(".cs", task.OutputFile.ItemSpec.Substring(task.OutputFile.ItemSpec.Length - 3)); 385File.Delete(task.OutputFile.ItemSpec); 404Assert.True(File.Exists(task.OutputFile.ItemSpec)); 405Assert.Equal(folder.ItemSpec, task.OutputFile.ItemSpec.Substring(0, folder.ItemSpec.Length)); 406Assert.Equal(".cs", task.OutputFile.ItemSpec.Substring(task.OutputFile.ItemSpec.Length - 3)); 463File.Delete(task.OutputFile.ItemSpec); 509string content = File.ReadAllText(task.OutputFile.ItemSpec); 514File.Delete(task.OutputFile.ItemSpec); 533string content = File.ReadAllText(task.OutputFile.ItemSpec); 538File.Delete(task.OutputFile.ItemSpec); 565string content = File.ReadAllText(task.OutputFile.ItemSpec); 571File.Delete(task.OutputFile.ItemSpec); 601string content = File.ReadAllText(task.OutputFile.ItemSpec); 610File.Delete(task.OutputFile.ItemSpec); 704string content = File.ReadAllText(task.OutputFile.ItemSpec); 712File.Delete(task.OutputFile.ItemSpec); 737string content = File.ReadAllText(task.OutputFile.ItemSpec); 742File.Delete(task.OutputFile.ItemSpec); 1104string content = File.ReadAllText(task.OutputFile.ItemSpec); 1118if ((task.OutputFile is not null) && File.Exists(task.OutputFile.ItemSpec)) 1120File.Delete(task.OutputFile.ItemSpec); 1142if ((task.OutputFile is not null) && File.Exists(task.OutputFile.ItemSpec)) 1144File.Delete(task.OutputFile.ItemSpec);

43Assert.False(File.Exists(a.File.ItemSpec)); 70Assert.Equal("\uBDEA", r.Lines[0].ItemSpec); 91Assert.NotEqual("\uBDEA", r.Lines[0].ItemSpec); 120r.Lines[0].ItemSpec.ShouldBe("File contents1"); 203r.Lines[0].ItemSpec.ShouldBe("File contents1");

80Assert.Equal(p.Result[i].ItemSpec, results[i]); 109Assert.Equal(p.Result[i].ItemSpec, results[i]); 138Assert.Equal(p.Result[i].ItemSpec, results[i]); 160Assert.Equal(p.Result[i].ItemSpec, results[i]); 180Assert.Equal(p.Result[i].ItemSpec, results[i]); 197Assert.Equal(xmlInputPath, p.XmlInputPath.ItemSpec); 357Assert.Equal(["abcdefg", "a$(d)fg", "a$(d.f)"], p.Result.Select(x => x.ItemSpec));

376using (StreamReader sr = new StreamReader(t.OutputPaths[0].ItemSpec)) 413using (StreamReader sr = new StreamReader(t.OutputPaths[0].ItemSpec)) 888using (StreamReader sr = new StreamReader(t.OutputPaths[0].ItemSpec))

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));

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);

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

89DateTime lastWriteTime = NativeMethodsShared.GetLastWriteFileUtcTime(item.ItemSpec); 93FileTracker.LogMessageFromResources(log, MessageImportance.Low, "Tracking_OutputDoesNotExist", item.ItemSpec); 101requestedFilename = item.ItemSpec;

167string fullexcludePath = FileUtilities.EnsureNoTrailingSlash(FileUtilities.NormalizePath(excludePath.ItemSpec)).ToUpperInvariant(); 258FileTracker.LogMessageFromResources(_log, MessageImportance.Low, trackerCompileReason, compileSource.ItemSpec, modifiedPath, modifiedTime); 262FileTracker.LogMessageFromResources(_log, MessageImportance.Low, trackerCompileReason, compileSource.ItemSpec, modifiedPath); 266FileTracker.LogMessageFromResources(_log, MessageImportance.Low, trackerCompileReason, compileSource.ItemSpec, outputFilePath); 270FileTracker.LogMessageFromResources(_log, MessageImportance.Low, trackerCompileReason, compileSource.ItemSpec); 319private static int CompareTaskItems(ITaskItem left, ITaskItem right) => string.Compare(left.ItemSpec, right.ItemSpec, StringComparison.Ordinal); 441if (string.Equals(dependee, fileToIgnore.ItemSpec, StringComparison.OrdinalIgnoreCase)) 467string sourceFullPath = FileUtilities.NormalizePath(sourceFile.ItemSpec); 599if (!FileUtilities.FileExistsNoThrow(tlogFileName.ItemSpec)) 601FileTracker.LogMessageFromResources(_log, MessageImportance.Low, "Tracking_SingleLogFileNotAvailable", tlogFileName.ItemSpec); 629FileTracker.LogMessage(_log, MessageImportance.Low, "\t{0}", tlogItem.ItemSpec); 645FileTracker.LogMessage(_log, MessageImportance.Low, "\t{0}", tlogFileName.ItemSpec); 647using (StreamReader tlog = File.OpenText(tlogFileName.ItemSpec)) 656invalidTLogName = tlogFileName.ItemSpec; 671invalidTLogName = tlogFileName.ItemSpec; 693if (!primaryFiles.ContainsKey(FileUtilities.NormalizePath(file.ItemSpec))) 695primaryFiles.Add(FileUtilities.NormalizePath(file.ItemSpec), null); 736invalidTLogName = tlogFileName.ItemSpec; 764invalidTLogName = tlogFileName.ItemSpec; 874string firstTlog = _tlogFiles[0].ItemSpec; 879File.WriteAllText(tlogFile.ItemSpec, "", System.Text.Encoding.Unicode); 950DependencyTable.Remove(FileUtilities.NormalizePath(sourceItem.ItemSpec)); 993dependencies.Remove(FileUtilities.NormalizePath(dependencyToRemove.ItemSpec));

143FileTracker.LogMessage(_log, MessageImportance.Low, "\t{0}", tlogItem.ItemSpec); 157FileTracker.LogMessage(_log, MessageImportance.Low, "\t{0}", tlogFileName.ItemSpec); 161using (StreamReader tlog = File.OpenText(tlogFileName.ItemSpec)) 170invalidTLogName = tlogFileName.ItemSpec; 181invalidTLogName = tlogFileName.ItemSpec; 201invalidTLogName = tlogFileName.ItemSpec; 351string upperSourceRoot = FileUtilities.NormalizePath(source.ItemSpec); 526AddOutput(dependencies, FileUtilities.NormalizePath(computedOutput.ItemSpec)); 586string firstTlog = _tlogFiles[0].ItemSpec; 591File.WriteAllText(tlogFile.ItemSpec, "", System.Text.Encoding.Unicode); 651DependencyTable.Remove(FileUtilities.NormalizePath(sourceItem.ItemSpec)); 687dependencies.Remove(FileUtilities.NormalizePath(dependencyToRemove.ItemSpec));

45string tlogFilename = FileUtilities.NormalizePath(tlogFile.ItemSpec); 95normalizedFile.ItemSpec = NormalizeTlogPath(tlogFiles[i].ItemSpec); 217return string.Equals(x.ItemSpec, y.ItemSpec, StringComparison.OrdinalIgnoreCase); 225public int GetHashCode(ITaskItem obj) => obj == null ? 0 : StringComparer.OrdinalIgnoreCase.GetHashCode(obj.ItemSpec); 257string tlogFilename = FileUtilities.NormalizePath(tlogFiles[tlogItemCount].ItemSpec);

350rootSources.Add(FileUtilities.NormalizePath(source.ItemSpec).ToUpperInvariant()); 355rootSources.Add(FileUtilities.NormalizePath(output.ItemSpec).ToUpperInvariant());

285ignore.Add(tlogFileToIgnore.ItemSpec); 290if (!ignore.Contains(tlogFile.ItemSpec)) 315_tlogMarker = tlogFilesLocal[0].ItemSpec 392FileTracker.LogMessage(_log, MessageImportance.Low, "\t{0}", tlogItem.ItemSpec); 407FileTracker.LogMessage(_log, MessageImportance.Low, "\t{0}", tlogFileName.ItemSpec); 409DateTime tlogLastWriteTimeUtc = NativeMethodsShared.GetLastWriteFileUtcTime(tlogFileName.ItemSpec); 413NewestTLogFileName = tlogFileName.ItemSpec; 416using (StreamReader tlog = File.OpenText(tlogFileName.ItemSpec)) 425invalidTLogName = tlogFileName.ItemSpec; 441invalidTLogName = tlogFileName.ItemSpec; 513DateTime tlogLastWriteTimeUtc = NativeMethodsShared.GetLastWriteFileUtcTime(tlogFileName.ItemSpec); 517NewestTLogFileName = tlogFileName.ItemSpec; 621string firstTlog = TlogFiles[0].ItemSpec; 626File.WriteAllText(tlogFile.ItemSpec, "", Encoding.Unicode); 870trackedFilesToRemove.Add(FileUtilities.NormalizePath(removeFile.ItemSpec), removeFile);

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))

117return GetAbsolutePath(documentItem.ItemSpec); 221var trimmed = item.ItemSpec.Trim();

226.Select(item => item.ItemSpec) 242=> !Path.GetFileName(item.ItemSpec).StartsWith("TemporaryGeneratedFile_", StringComparison.Ordinal); 275var filePath = documentItem.ItemSpec; 296=> GetAbsolutePathRelativeToProject(documentItem.ItemSpec); 319return !_documents.ContainsKey(GetAbsolutePathRelativeToProject(documentItem.ItemSpec)); 332var filePath = documentItem.ItemSpec;

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

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))

50var itemSpec = sourceRoot.ItemSpec;

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

77group item by item.ItemSpec

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

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

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

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

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

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

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);

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))

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

75FeedKeys = feedKeys.ToImmutableDictionary(i => i.ItemSpec, i => i.GetMetadata("Key")); 76FeedSasUris = feedSasUris.ToImmutableDictionary(i => i.ItemSpec, i => ConvertFromBase64(i.GetMetadata("Base64Uri"))); 77FeedOverrides = feedOverrides.ToImmutableDictionary(i => i.ItemSpec, i => i.GetMetadata("Replacement"));

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

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

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

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

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

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

96builder.AddRequiredCapability(require.ItemSpec, require.GetMetadata("Version")); 101builder.AddConflict(conflict.ItemSpec); 106builder.AddChangelogLine(Packager, changelogLine.ItemSpec); 112HashSet<string> ownedDirectories = new(OwnedDirectories.Select(d => d.ItemSpec)); 116builder.AddScript(script.GetMetadata("Kind"), File.ReadAllText(script.ItemSpec)); 121Dictionary<string, string> filePathToKind = RawPayloadFileKinds.Select(k => k.ItemSpec.Split(':')).ToDictionary(k => k[0], k => k[1].Trim());

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);

43foreach (var group in Properties.GroupBy(item => item.ItemSpec)) 139Log.LogError($"Item '{item.ItemSpec}' has no String or Object value.");

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 " +

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;

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

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

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

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)

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

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}");

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);

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"));

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)))

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

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

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

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

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

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);

191return nuspecProperties == null ? null : NuspecPropertyStringProvider.GetNuspecPropertyProviderFunction(nuspecProperties.Select(p => p.ItemSpec).ToArray()); 370? _libPackageExcludes.Concat(AdditionalLibPackageExcludes?.Select(item => item.ItemSpec) ?? Enumerable.Empty<string>()) 371: LibPackageExcludes.Select(item => item.ItemSpec); 380.Concat(AdditionalSymbolPackageExcludes?.Select(item => item.ItemSpec) ?? Enumerable.Empty<string>());

104Id = item.ItemSpec;

68Name = originalItem.ItemSpec;

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

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;

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

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}");

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

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

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");

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");

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));

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

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

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

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

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

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

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

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

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"));

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"));

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

59string shortUrl = link.ItemSpec;

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

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

72string key = item.ItemSpec;

54string sourceFile = item.ItemSpec;

155"sdk" => $"{feed.ItemSpec}/Sdk/{version}/dotnet-sdk-{effectiveVersion}-{Runtime}.{extension}{sasToken}", 157$"{feed.ItemSpec}/aspnetcore/Runtime/{version}/aspnetcore-runtime-{effectiveVersion}-{Runtime}.{extension}{sasToken}", 158_ => $"{feed.ItemSpec}/Runtime/{version}/dotnet-runtime-{effectiveVersion}-{Runtime}.{extension}{sasToken}" 187"sdk" => await GetMatchingProductVersionTxtContents($"{feed.ItemSpec}/Sdk/{version}", "sdk-productVersion.txt", sasToken), 188"aspnetcore-runtime" => await GetMatchingProductVersionTxtContents($"{feed.ItemSpec}/aspnetcore/Runtime/{version}", "aspnetcore-productVersion.txt", sasToken), 189_ => await GetMatchingProductVersionTxtContents($"{feed.ItemSpec}/Runtime/{version}", "runtime-productVersion.txt", sasToken) 329"sdk" => $"{feed.ItemSpec}/Sdk/{Channel}/latest.version", 330"aspnetcore-runtime" => $"{feed.ItemSpec}/aspnetcore/Runtime/{Channel}/latest.version", 331_ => $"{feed.ItemSpec}/Runtime/{Channel}/latest.version"

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

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

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

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

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

133var name = ignoredReference.ItemSpec;

131ignoredTypes.Add(ignoredType.ItemSpec);

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}");

30Name = file.ItemSpec,

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,

61string filePath = file.ItemSpec;

133var name = ignoredReference.ItemSpec;

131ignoredTypes.Add(ignoredType.ItemSpec);

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

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

243var itemsToSign = ItemsToSign.Select(i => new ItemToSign(i.ItemSpec, i.GetMetadata(SignToolConstants.CollisionPriorityId))).OrderBy(i => i.CollisionPriorityId).ToList(); 277ItemsToSkipStrongNameCheck?.Select(i => i.ItemSpec).ToArray(), 316var certificateName = certificateSignInfo.ItemSpec; 368if (!Path.IsPathRooted(itemToSign.ItemSpec)) 374var directoryParts = Path.GetFullPath(Path.GetDirectoryName(itemToSign.ItemSpec)).Split(separators); 421var extension = item.ItemSpec; 468var strongName = item.ItemSpec; 524var fileName = item.ItemSpec;

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

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

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);

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

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

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

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

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

72EscapeValue(item.ItemSpec, builder);

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

53Assert.Equal(identity, output.ItemSpec); 111Assert.Equal(identity, output.ItemSpec); 169Assert.Equal(identity, output.ItemSpec); 227Assert.Equal(identity, output.ItemSpec); 377Assert.Equal(identity, output.ItemSpec); 440Assert.Equal(identity, output.ItemSpec); 540Assert.Equal(identity12, output.ItemSpec); 552Assert.Equal(identity12, output.ItemSpec); 564Assert.Equal(identity3, output.ItemSpec);

126Assert.Equal(identity, item.ItemSpec); 152Assert.Equal(identity, item.ItemSpec); 167Assert.Equal(value, item.ItemSpec); 250input.SetupGet(i => i.ItemSpec).Returns(identity).Verifiable(); 263input.VerifyGet(i => i.ItemSpec, Times.Once); 277input.SetupGet(i => i.ItemSpec).Returns(identity).Verifiable(); 287input.VerifyGet(i => i.ItemSpec, Times.Once); 300input.SetupGet(i => i.ItemSpec).Returns(value).Verifiable(); 310input.VerifyGet(i => i.ItemSpec, Times.Once);

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

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

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

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

48 ? Normalize(item.ItemSpec)

79 info.ItemSpec = image.ItemSpec;

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

315escapedItemSpec = EscapingUtilities.Escape(copyFrom.ItemSpec); 419escapedItemSpec = EscapingUtilities.Escape(wrappedItem.ItemSpec);

315escapedItemSpec = EscapingUtilities.Escape(copyFrom.ItemSpec); 419escapedItemSpec = EscapingUtilities.Escape(wrappedItem.ItemSpec);

42Log.LogMessage(item.ItemSpec);

294ItemSpec = inputItem.ItemSpec,

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

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);

602refpath = References[i].ItemSpec;

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

171string resourcesFile = OutputResourcesFile[0].ItemSpec; 180string resFileName = resourceFile.ItemSpec; 294strFileName = inputFile.ItemSpec; 317resFile.ItemSpec,

207Log.LogMessageFromResources(nameof(SR.CheckingUids), inputFile.ItemSpec); 212UidCollector collector = ParseFile(inputFile.ItemSpec); 224UidCollector collector = ParseFile(inputFile.ItemSpec); 239string tempFile = GetTempFileName(inputFile.ItemSpec); 242string backupFile = GetBackupFileName(inputFile.ItemSpec); 246using (Stream source = File.OpenRead(inputFile.ItemSpec)) 254RenameFile(inputFile.ItemSpec, backupFile); 257RenameFile(tempFile, inputFile.ItemSpec); 276UidCollector collector = ParseFile(inputFile.ItemSpec); 293string tempFile = GetTempFileName(inputFile.ItemSpec); 296string backupFile = GetBackupFileName(inputFile.ItemSpec); 300using (Stream source = File.OpenRead(inputFile.ItemSpec)) 308RenameFile(inputFile.ItemSpec, backupFile); 311RenameFile(tempFile, inputFile.ItemSpec);

72string appManifestFile = ApplicationManifest[0].ItemSpec;

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

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

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