299string ITaskItem.ItemSpec 924public string ItemSpec

649public string ItemSpec

2132public 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; }

649public string ItemSpec

387string ITaskItem.ItemSpec { get; set; }

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

180public string ItemSpec

649public string ItemSpec

577public string ItemSpec

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

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

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

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

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

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

3059suggestedRedirect.ItemSpec = itemSpec;

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

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

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

46item.ItemSpec = "|||";

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

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

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

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

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

46string bid = batchId.ItemSpec;

42if (File.Exists(item.ItemSpec)) 43size = new FileInfo(item.ItemSpec).Length;

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

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

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

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

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

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

242writer.Write(taskItem.ItemSpec);

189sb.Append(item.ItemSpec);

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

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

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

133yield return taskItem.ItemSpec;

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

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

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

1119project.OutputPath = output.ItemSpec.AsMemory(); 1132?.ItemSpec.AsMemory();

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

149((ITaskItem)listValue[0]!).ItemSpec.ShouldBe("item1"); 150((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}')"); 3768Assert.Equal("InitialValue", results.ResultsByTarget["BuildOther"].Items.First().ItemSpec); 3790Assert.Equal(newPropertyValue, results.ResultsByTarget["Foo"].Items.First().ItemSpec); 3854string.Join(";", result.ResultsByTarget["MainTarget"].Items.Select(i => i.ItemSpec)));

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

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

379Assert.Equal("foo.o", results.Items[0].ItemSpec); 399Assert.Equal("testProject.proj", results.Items[0].ItemSpec); 695Assert.Equal("item1", outputListB[0].ItemSpec); 707Assert.Equal("item1", outputListB[0].ItemSpec); 711Assert.Equal("item2", outputListC[0].ItemSpec);

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

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

180buildEngineResult.TargetOutputsPerProject[0]["Build"][0].ItemSpec.ShouldBe("item1.dll");

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

236sb.Append(taskItem.ItemSpec);

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

1326if (item.ItemSpec.EndsWith("ClassLibrary1.csproj")) 1330else if (item.ItemSpec.EndsWith("MainApp.metaproj")) 1334else if (item.ItemSpec == "Debug|Mixed Platforms") 1340else if (item.ItemSpec == "Release|Any CPU") 1348Assert.Fail("Unexpected project seen:" + item.ItemSpec);

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

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

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

140.ItemSpec.ShouldBe("1"); 171resultFromCachedBuild.ResultsByTarget["Build"].Items.First().ItemSpec.ShouldBe("1"); 361rootNodeBuildResult.ResultsByTarget["Build"].Items.Select(i => i.ItemSpec).ToArray().ShouldBe(expectedOutput[rootNode]); 480var actualOutput = result.ResultsByTarget["Build"].Items.Select(i => i.ItemSpec).ToArray();

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

203Assert.Equal("foo", foo.ItemSpec); 212Assert.Equal("foo", foo2.ItemSpec); 231Assert.Equal("foo", foo.ItemSpec); 242Assert.Equal("foo", foo2.ItemSpec); 260Assert.Equal("foo", wrappedParameter[0].ItemSpec); 261Assert.Equal("bar", wrappedParameter[1].ItemSpec); 271Assert.Equal("foo", wrappedParameter2[0].ItemSpec); 272Assert.Equal("bar", wrappedParameter2[1].ItemSpec); 288Assert.Equal("foo;bar", foo.ItemSpec); 297Assert.Equal("foo;bar", foo2.ItemSpec); 313Assert.Equal("foo%3bbar", foo.ItemSpec); 322Assert.Equal("foo%3bbar", foo2.ItemSpec); 333Assert.Equal("foo%3bbar", foo4.ItemSpec); 349Assert.Equal("foo;bar", foo.ItemSpec); 359Assert.Equal("foo;bar", foo2.ItemSpec); 380Assert.Equal("foo", foo.ItemSpec); 391Assert.Equal("foo", foo2.ItemSpec); 413Assert.Equal("foo", foo.ItemSpec); 424Assert.Equal("foo", foo2.ItemSpec); 437Assert.Equal("foo", foo4.ItemSpec); 460Assert.Equal("foo", foo.ItemSpec); 473Assert.Equal("foo", foo2.ItemSpec);

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

58EvaluatedInclude = ti.ItemSpec;

36ItemSpec = original.ItemSpec;

213writer.Write(taskItem.ItemSpec);

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

248AppendSwitchIfNotNull(switchName, parameter.ItemSpec);

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

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;

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

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

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

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

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

248AppendSwitchIfNotNull(switchName, parameter.ItemSpec);

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

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;

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

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

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

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

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

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

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

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

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;

575string itemSpec = referenceAssemblyName.ItemSpec; 708return new InvalidReferenceAssemblyNameException(referenceAssemblyName.ItemSpec); 889string itemSpec = referenceAssemblyFile.ItemSpec; 918throw new InvalidParameterValueException("AssemblyFiles", referenceAssemblyFile.ItemSpec, e.Message); 1511string dependeeItemSpec = dependee.ItemSpec; 1516if (string.Equals(dependeeItemSpec, assemblyReference.PrimarySourceItem.ItemSpec, StringComparison.OrdinalIgnoreCase)) 1572if (assemblyReference.IsPrimary && assemblyReference.PrimarySourceItem.ItemSpec.Equals(itemSpec, StringComparison.OrdinalIgnoreCase)) 3006_log.LogWarningWithCodeFromResources("ResolveAssemblyReference.PrimaryReferenceOutsideOfFramework", reference.PrimarySourceItem.ItemSpec /* primary item spec*/, reference.ReferenceVersion /*Version of dependent assembly*/, reference.ExclusionListLoggingProperties.HighestVersionInRedist /*Version found in redist*/); 3010_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*/); 3021_log.LogWarningWithCodeFromResources("ResolveAssemblyReference.PrimaryReferenceOutsideOfFrameworkUsingAttribute", reference.PrimarySourceItem.ItemSpec /* primary item spec*/, reference.FrameworkNameAttribute /*Version of dependent assembly*/, targetedFramework); 3025_log.LogWarningWithCodeFromResources("ResolveAssemblyReference.DependencyReferenceOutsideOfFrameworkUsingAttribute", referenceItem.ItemSpec /* primary item spec*/, assemblyName.FullName /*Dependent assemblyName*/, reference.FrameworkNameAttribute, targetedFramework); 3036_log.LogWarningWithCodeFromResources("ResolveAssemblyReference.PrimaryReferenceInAnotherFramework", reference.PrimarySourceItem.ItemSpec /* primary item spec*/, targetedFramework); 3040_log.LogWarningWithCodeFromResources("ResolveAssemblyReference.DependencyReferenceInAnotherFramework", referenceItem.ItemSpec /* primary item spec*/, assemblyName.FullName /*Dependent assemblyName*/, targetedFramework); 3051_log.LogWarningWithCodeFromResources("ResolveAssemblyReference.FailedToResolveReferenceBecausePrimaryAssemblyInExclusionList", reference.PrimarySourceItem.ItemSpec, targetedFramework); 3055_log.LogWarningWithCodeFromResources("ResolveAssemblyReference.FailBecauseDependentAssemblyInExclusionList", referenceItem.ItemSpec, assemblyName.FullName, targetedFramework);

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

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

162AssignedFiles[i].ItemSpec, 174existingCulture, AssignedFiles[i].ItemSpec, info.culture); 202AssignedFiles[i].ItemSpec); 206Log.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);

115!Path.IsPathRooted(Files[i].ItemSpec) && 117!Files[i].ItemSpec.Contains("." + Path.DirectorySeparatorChar) && 124targetPath = Files[i].ItemSpec; 131TaskEnvironment.GetAbsolutePath(Files[i].ItemSpec).GetCanonicalForm(); 142targetPath = Path.GetFileName(Files[i].ItemSpec); 149Path.GetFullPath(TaskEnvironment.GetAbsolutePath(Files[i].ItemSpec)); 160targetPath = Path.GetFileName(Files[i].ItemSpec);

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

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

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

245AppendSwitchIfNotNull(switchName, parameter.ItemSpec);

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

513string sourceSpec = SourceFiles[i].ItemSpec; 514string destSpec = DestinationFiles[i].ItemSpec; 623string destPath = destItem.ItemSpec; 679string sourceSpec = sourceItem.ItemSpec; 680string destSpec = destItem.ItemSpec; 829() => Path.Combine(DestinationFolder.ItemSpec, Path.GetFileName(SourceFiles[i].ItemSpec)), 830SourceFiles[i].ItemSpec, 831DestinationFolder.ItemSpec, 855ErrorUtilities.VerifyThrowArgumentLength(sourceFolder.ItemSpec); 856AbsolutePath src = FileUtilities.NormalizePath(TaskEnvironment.GetAbsolutePath(sourceFolder.ItemSpec)); 869sourceFolder.ItemSpec, 870DestinationFolder.ItemSpec, 878() => Path.Combine(DestinationFolder.ItemSpec, srcName, file), 879sourceFolder.ItemSpec, 880DestinationFolder.ItemSpec, 1062if (DestinationFolder != null && FileSystems.Default.FileExists(TaskEnvironment.GetAbsolutePath(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;

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

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

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

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

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

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

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

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

93string referenceIdentity = item.ItemSpec;

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

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

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

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); 1389string sourceFileName = Sources[i].ItemSpec; 1405Sources[i].SetMetadata("OutputResource", OutputResources[i].ItemSpec); 1407if (!FileSystems.Default.FileExists(Sources[i].ItemSpec)) 1410Log.LogErrorWithCodeFromResources("GenerateResource.ResourceNotFound", Sources[i].ItemSpec); 1411_unsuccessfullyCreatedOutFiles.Add(OutputResources[i].ItemSpec); 1417if (ShouldRebuildResgenOutputFile(Sources[i].ItemSpec, OutputResources[i].ItemSpec)) 1432if (nothingOutOfDate && FileSystems.Default.FileExists(Sources[0].ItemSpec)) 1475Log.LogErrorWithCodeFromResources("GenerateResource.DuplicateOutputFilenames", item.ItemSpec); 1481Log.LogErrorWithCodeFromResources("GenerateResource.InvalidFilename", item.ItemSpec, e.Message); 1634StronglyTypedFileName = ProcessResourceFiles.GenerateDefaultStronglyTypedFilename(provider, OutputResources[0].ItemSpec); 1643_unsuccessfullyCreatedOutFiles.Add(OutputResources[0].ItemSpec); 1653DateTime sourceTime = NativeMethodsShared.GetLastWriteFileUtcTime(Sources[0].ItemSpec); 1660Log.LogMessageFromResources(MessageImportance.Low, "GenerateResource.InputDoesntExist", Sources[0].ItemSpec); 1672Log.LogMessageFromResources(MessageImportance.Low, "GenerateResource.InputNewer", Sources[0].ItemSpec, StronglyTypedFileName); 1712DateTime time = NativeMethodsShared.GetLastWriteFileUtcTime(input.ItemSpec); 1717_newestUncorrelatedInput = input.ItemSpec; 1726_newestUncorrelatedInput = input.ItemSpec; 2063OutputResources[i] = new TaskItem(Path.ChangeExtension(Sources[i].ItemSpec, ".resources")); 2068Log.LogErrorWithCodeFromResources("GenerateResource.InvalidFilename", Sources[i].ItemSpec, e.Message); 2112_unsuccessfullyCreatedOutFiles.Contains(OutputResources[i].ItemSpec)) 2143if (StateFile?.ItemSpec.Length > 0) 2162provider, OutputResources[0].ItemSpec); 2185_cache = ResGenDependencies.DeserializeCache(StateFile?.ItemSpec, UseSourcePath, Log); 2197_cache.SerializeCache(StateFile?.ItemSpec, Log); 2438string outputSpec = _extractResWFiles ? resWOutputDirectory : _outFiles[i].ItemSpec; 2439if (!ProcessFile(_inFiles[i].ItemSpec, outputSpec)) 2524if (assemblyFile.ItemSpec != null && FileSystems.Default.FileExists(assemblyFile.ItemSpec)) 2540_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);

65string? buildProjectReferenceAs = PlatformNegotiation.GetNearestPlatform(projectReferenceOverridePlatformNegotiationMetadata, referencedProjectPlatform, projectReferencePlatformsMetadata, projectReferenceLookupTableMetadata, PlatformLookupTable, AssignedProjectsWithPlatform[i].ItemSpec, CurrentProjectPlatform, Log); 68Log.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;

82string 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";

70TaskEnvironment.GetAbsolutePath(FileUtilities.FixFilePath(Path.ItemSpec)).GetCanonicalForm()); 77System.IO.Path.GetFullPath(TaskEnvironment.GetAbsolutePath(FileUtilities.FixFilePath(Path.ItemSpec)))); 86"FindUnderPath.InvalidParameter", "Path", Path.ItemSpec, e.Message); 92Log.LogMessageFromResources(MessageImportance.Low, "FindUnderPath.ComparisonPath", Path.ItemSpec); 103TaskEnvironment.GetAbsolutePath(FileUtilities.FixFilePath(item.ItemSpec)).GetCanonicalForm()); 110System.IO.Path.GetFullPath(TaskEnvironment.GetAbsolutePath(FileUtilities.FixFilePath(item.ItemSpec)))); 117"FindUnderPath.InvalidParameter", "Files", item.ItemSpec, e.Message);

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

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

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

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

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

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

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

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

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

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

57SigningTarget.ItemSpec,

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

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

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

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

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

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

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

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

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

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

2955if (String.Equals(item.ItemSpec, spec, StringComparison.OrdinalIgnoreCase)) 3051Assert.Equal(loadModeResolvedFiles[i].ItemSpec, t.ResolvedFiles[i].ItemSpec); 3095Assert.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);

29t.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);

1644Assert.Equal(validOutFile, t.CopiedFiles[0].ItemSpec); 1649Assert.Equal(invalidFile, t.DestinationFiles[0].ItemSpec); 1650Assert.Equal(validOutFile, t.DestinationFiles[1].ItemSpec); 1651Assert.Equal(validOutFile, t.CopiedFiles[0].ItemSpec); 1720Assert.Equal(file, t.DestinationFiles[0].ItemSpec); 1740Assert.Equal(file, t.DestinationFiles[0].ItemSpec); 1793Assert.Equal(filename.ToLowerInvariant(), t.DestinationFiles[0].ItemSpec); 1849Assert.Equal(file, t.DestinationFiles[0].ItemSpec); 1850Assert.Equal(dest2, t.DestinationFiles[1].ItemSpec); 1851Assert.Equal(file, t.CopiedFiles[0].ItemSpec); 1932Assert.Equal(destFile, t.DestinationFiles[0].ItemSpec); 1933Assert.Equal(destFile, t.CopiedFiles[0].ItemSpec); 1994Assert.Equal(destFile, t.DestinationFiles[0].ItemSpec); 1995Assert.Equal(destFile, t.CopiedFiles[0].ItemSpec); 2025using (StreamWriter sw = FileUtilities.OpenWrite(item.ItemSpec, false)) // HIGHCHAR: Test writes in UTF8 without preamble. 2084using (StreamWriter sw = FileUtilities.OpenWrite(item.ItemSpec, false)) // HIGHCHAR: Test writes in UTF8 without preamble. 2640Assert.Equal(destFile, t.DestinationFiles[0].ItemSpec); 2641Assert.Equal(destFile, t.CopiedFiles[0].ItemSpec); 2740Assert.Equal(destFile1, t.DestinationFiles[0].ItemSpec); 2741Assert.Equal(destFile2, t.DestinationFiles[1].ItemSpec); 2742Assert.Equal(destFile1, t.CopiedFiles[0].ItemSpec); 2743Assert.Equal(destFile2, t.CopiedFiles[1].ItemSpec); 2834Assert.Equal(destFile, t.DestinationFiles[0].ItemSpec); 2835Assert.Equal(destFile, t.CopiedFiles[0].ItemSpec); 2900Assert.Equal(destFile, t.DestinationFiles[0].ItemSpec); 2901Assert.Equal(destFile, t.CopiedFiles[0].ItemSpec);

374Assert.Equal(@"CustomToolTest.SR1", resourceNames[0].ItemSpec); 403t.ManifestResourceNames[0].ItemSpec.ShouldBe("MyStuff.Namespace.Class", "Expecting to find the namespace & class name from SR1.cs"); 443t.ManifestResourceNames[0].ItemSpec.ShouldBe(ResourceFileName, "Expecting to find the namespace & class name from SR1.cs"); 476t.ManifestResourceNames[0].ItemSpec.ShouldBe("MyStuff.Namespace.Class", "Expecting to find the namespace & class name from SR1.cs"); 510t.ManifestResourceNames[0].ItemSpec.ShouldBe("SR1", "Expected only the file name."); 541t.ManifestResourceNames[0].ItemSpec.ShouldBe("MyStuff2.Namespace.Class2", "Expected the namespace & class of SR2."); 575t.ManifestResourceNames[0].ItemSpec.ShouldBe("SR1", "Expected only the file name."); 612t.ManifestResourceNames[0].ItemSpec.ShouldBe("MyStuff.Namespace.Class.de", "Expected Namespace.Class.Culture"); 807Assert.Equal(@"strings.resx", resourceFiles[0].ItemSpec); 833Assert.Equal(@"pic.bmp", resourceFiles[0].ItemSpec); 859Assert.Equal(@"pic.bmp", resourceFiles[0].ItemSpec); 884Assert.Equal(@"strings.resx", resourceFiles[0].ItemSpec);

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

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

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

1068exec.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);

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

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

434Assert.Equal(winmd, t.References[0].ItemSpec, true); 435Assert.Equal("A.winmd", Path.GetFileName(t.References[0].ItemSpec), true); 444Assert.Equal("E.dll", Path.GetFileName(t.References[4].ItemSpec), true); 453Assert.Equal("A.winmd", Path.GetFileName(t.CopyLocalFiles[0].ItemSpec), true); 462Assert.Equal("E.dll", Path.GetFileName(t.CopyLocalFiles[5].ItemSpec), true); 471Assert.Equal("B.xml", Path.GetFileName(t.CopyLocalFiles[2].ItemSpec)); 556Assert.Equal("A.winmd", Path.GetFileName(t.References[0].ItemSpec), true); 565Assert.Equal("B.winmd", Path.GetFileName(t.References[1].ItemSpec), true); 574Assert.Equal("E.dll", Path.GetFileName(t.References[4].ItemSpec), true); 609string sdkRoot = item.ItemSpec; 634Assert.DoesNotContain(references1, i => i.ItemSpec.Equals(ref2.ItemSpec, StringComparison.InvariantCultureIgnoreCase)); 639string sdkRoot2 = item.ItemSpec; 674engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingReference", t.References[0].ItemSpec.Replace(t.References[0].GetMetadata("SDKRootPath"), String.Empty)); 675engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingReference", t.References[1].ItemSpec.Replace(t.References[1].GetMetadata("SDKRootPath"), String.Empty)); 676engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingReference", t.References[2].ItemSpec.Replace(t.References[2].GetMetadata("SDKRootPath"), String.Empty)); 677engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingReference", t.References[3].ItemSpec.Replace(t.References[3].GetMetadata("SDKRootPath"), String.Empty)); 678engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingReference", t.References[4].ItemSpec.Replace(t.References[4].GetMetadata("SDKRootPath"), String.Empty)); 679engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingReference", t.References[5].ItemSpec.Replace(t.References[5].GetMetadata("SDKRootPath"), String.Empty)); 680engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingReference", t.References[6].ItemSpec.Replace(t.References[6].GetMetadata("SDKRootPath"), String.Empty)); 681engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingReference", t.References[7].ItemSpec.Replace(t.References[7].GetMetadata("SDKRootPath"), String.Empty)); 683Assert.Equal("A.winmd", Path.GetFileName(t.References[0].ItemSpec)); 690Assert.Equal("E.dll", Path.GetFileName(t.References[4].ItemSpec)); 723engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingReference", t.References[0].ItemSpec.Replace(t.References[0].GetMetadata("SDKRootPath"), String.Empty)); 724engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingReference", t.References[1].ItemSpec.Replace(t.References[1].GetMetadata("SDKRootPath"), String.Empty)); 725engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingReference", t.References[2].ItemSpec.Replace(t.References[2].GetMetadata("SDKRootPath"), String.Empty)); 726engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingReference", t.References[3].ItemSpec.Replace(t.References[3].GetMetadata("SDKRootPath"), String.Empty)); 727engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingReference", t.References[4].ItemSpec.Replace(t.References[4].GetMetadata("SDKRootPath"), String.Empty)); 729Assert.Equal("A.dll", Path.GetFileName(t.References[0].ItemSpec), true); 736Assert.Equal("h.dll", Path.GetFileName(t.References[4].ItemSpec), true); 815engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingReference", t.References[0].ItemSpec.Replace(t.References[0].GetMetadata("SDKRootPath"), String.Empty)); 816engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingReference", t.References[1].ItemSpec.Replace(t.References[1].GetMetadata("SDKRootPath"), String.Empty)); 817engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingReference", t.References[2].ItemSpec.Replace(t.References[2].GetMetadata("SDKRootPath"), String.Empty)); 818engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingReference", t.References[3].ItemSpec.Replace(t.References[3].GetMetadata("SDKRootPath"), String.Empty)); 819engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingReference", t.References[4].ItemSpec.Replace(t.References[4].GetMetadata("SDKRootPath"), String.Empty)); 820engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingReference", t.References[5].ItemSpec.Replace(t.References[5].GetMetadata("SDKRootPath"), String.Empty)); 821engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingReference", t.References[6].ItemSpec.Replace(t.References[6].GetMetadata("SDKRootPath"), String.Empty)); 822engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingReference", t.References[7].ItemSpec.Replace(t.References[7].GetMetadata("SDKRootPath"), String.Empty)); 824Assert.True(t.References[0].ItemSpec.IndexOf("x64", StringComparison.OrdinalIgnoreCase) > -1); 825Assert.Equal("A.winmd", Path.GetFileName(t.References[0].ItemSpec)); 834Assert.Equal("E.dll", Path.GetFileName(t.References[4].ItemSpec)); 867engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingReference", t.References[0].ItemSpec.Replace(t.References[0].GetMetadata("SDKRootPath"), String.Empty)); 868engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingReference", t.References[1].ItemSpec.Replace(t.References[1].GetMetadata("SDKRootPath"), String.Empty)); 869engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingReference", t.References[2].ItemSpec.Replace(t.References[2].GetMetadata("SDKRootPath"), String.Empty)); 870engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingReference", t.References[3].ItemSpec.Replace(t.References[3].GetMetadata("SDKRootPath"), String.Empty)); 871engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingReference", t.References[4].ItemSpec.Replace(t.References[4].GetMetadata("SDKRootPath"), String.Empty)); 872engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingReference", t.References[5].ItemSpec.Replace(t.References[5].GetMetadata("SDKRootPath"), String.Empty)); 873engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingReference", t.References[6].ItemSpec.Replace(t.References[6].GetMetadata("SDKRootPath"), String.Empty)); 874engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingReference", t.References[7].ItemSpec.Replace(t.References[7].GetMetadata("SDKRootPath"), String.Empty)); 876Assert.True(t.References[0].ItemSpec.IndexOf("x64", StringComparison.OrdinalIgnoreCase) > -1); 877Assert.Equal("A.winmd", Path.GetFileName(t.References[0].ItemSpec)); 886Assert.Equal("E.dll", Path.GetFileName(t.References[4].ItemSpec)); 918engine.AssertLogDoesntContainMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingReference", t.References[0].ItemSpec.Replace(t.References[0].GetMetadata("SDKRootPath"), String.Empty)); 919engine.AssertLogDoesntContainMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingReference", t.References[1].ItemSpec.Replace(t.References[1].GetMetadata("SDKRootPath"), String.Empty)); 920engine.AssertLogDoesntContainMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingReference", t.References[2].ItemSpec.Replace(t.References[2].GetMetadata("SDKRootPath"), String.Empty)); 921engine.AssertLogDoesntContainMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingReference", t.References[3].ItemSpec.Replace(t.References[3].GetMetadata("SDKRootPath"), String.Empty)); 922engine.AssertLogDoesntContainMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingReference", t.References[4].ItemSpec.Replace(t.References[4].GetMetadata("SDKRootPath"), String.Empty)); 923engine.AssertLogDoesntContainMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingReference", t.References[5].ItemSpec.Replace(t.References[5].GetMetadata("SDKRootPath"), String.Empty)); 924engine.AssertLogDoesntContainMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingReference", t.References[6].ItemSpec.Replace(t.References[6].GetMetadata("SDKRootPath"), String.Empty)); 925engine.AssertLogDoesntContainMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingReference", t.References[7].ItemSpec.Replace(t.References[7].GetMetadata("SDKRootPath"), String.Empty)); 956engine.AssertLogDoesntContainMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingRedistFile", t.RedistFiles[0].ItemSpec.Replace(t.RedistFiles[0].GetMetadata("SDKRootPath"), String.Empty), t.RedistFiles[0].GetMetadata("TargetPath")); 957engine.AssertLogDoesntContainMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingRedistFile", t.RedistFiles[1].ItemSpec.Replace(t.RedistFiles[1].GetMetadata("SDKRootPath"), String.Empty), t.RedistFiles[1].GetMetadata("TargetPath")); 958engine.AssertLogDoesntContainMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingRedistFile", t.RedistFiles[2].ItemSpec.Replace(t.RedistFiles[2].GetMetadata("SDKRootPath"), String.Empty), t.RedistFiles[2].GetMetadata("TargetPath")); 959engine.AssertLogDoesntContainMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingRedistFile", t.RedistFiles[3].ItemSpec.Replace(t.RedistFiles[3].GetMetadata("SDKRootPath"), String.Empty), t.RedistFiles[3].GetMetadata("TargetPath")); 960engine.AssertLogDoesntContainMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingRedistFile", t.RedistFiles[4].ItemSpec.Replace(t.RedistFiles[4].GetMetadata("SDKRootPath"), String.Empty), t.RedistFiles[4].GetMetadata("TargetPath")); 962Assert.Equal("A.dll", Path.GetFileName(t.RedistFiles[0].ItemSpec)); 968Assert.Equal("B.dll", Path.GetFileName(t.RedistFiles[1].ItemSpec), true); 974Assert.Equal("B.PRI", Path.GetFileName(t.RedistFiles[2].ItemSpec), true); 980Assert.Equal("C.dll", Path.GetFileName(t.RedistFiles[3].ItemSpec), true); 986Assert.Equal("D.dll", Path.GetFileName(t.RedistFiles[4].ItemSpec), true); 1017engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingRedistFile", t.RedistFiles[0].ItemSpec.Replace(t.RedistFiles[0].GetMetadata("SDKRootPath"), String.Empty), t.RedistFiles[0].GetMetadata("TargetPath")); 1018engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingRedistFile", t.RedistFiles[1].ItemSpec.Replace(t.RedistFiles[1].GetMetadata("SDKRootPath"), String.Empty), t.RedistFiles[1].GetMetadata("TargetPath")); 1019engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingRedistFile", t.RedistFiles[2].ItemSpec.Replace(t.RedistFiles[2].GetMetadata("SDKRootPath"), String.Empty), t.RedistFiles[2].GetMetadata("TargetPath")); 1020engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingRedistFile", t.RedistFiles[3].ItemSpec.Replace(t.RedistFiles[3].GetMetadata("SDKRootPath"), String.Empty), t.RedistFiles[3].GetMetadata("TargetPath")); 1021engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingRedistFile", t.RedistFiles[4].ItemSpec.Replace(t.RedistFiles[4].GetMetadata("SDKRootPath"), String.Empty), t.RedistFiles[4].GetMetadata("TargetPath")); 1048Assert.True(t.RedistFiles[0].ItemSpec.IndexOf("x64", StringComparison.OrdinalIgnoreCase) > -1); 1049engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingRedistFile", t.RedistFiles[0].ItemSpec.Replace(t.RedistFiles[0].GetMetadata("SDKRootPath"), String.Empty), t.RedistFiles[0].GetMetadata("TargetPath")); 1050engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingRedistFile", t.RedistFiles[1].ItemSpec.Replace(t.RedistFiles[1].GetMetadata("SDKRootPath"), String.Empty), t.RedistFiles[1].GetMetadata("TargetPath")); 1051engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingRedistFile", t.RedistFiles[2].ItemSpec.Replace(t.RedistFiles[2].GetMetadata("SDKRootPath"), String.Empty), t.RedistFiles[2].GetMetadata("TargetPath")); 1052engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingRedistFile", t.RedistFiles[3].ItemSpec.Replace(t.RedistFiles[3].GetMetadata("SDKRootPath"), String.Empty), t.RedistFiles[3].GetMetadata("TargetPath")); 1053engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingRedistFile", t.RedistFiles[4].ItemSpec.Replace(t.RedistFiles[4].GetMetadata("SDKRootPath"), String.Empty), t.RedistFiles[4].GetMetadata("TargetPath")); 1080Assert.True(t.RedistFiles[0].ItemSpec.IndexOf("x64", StringComparison.OrdinalIgnoreCase) > -1); 1081engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingRedistFile", t.RedistFiles[0].ItemSpec.Replace(t.RedistFiles[0].GetMetadata("SDKRootPath"), String.Empty), t.RedistFiles[0].GetMetadata("TargetPath")); 1082engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingRedistFile", t.RedistFiles[1].ItemSpec.Replace(t.RedistFiles[1].GetMetadata("SDKRootPath"), String.Empty), t.RedistFiles[1].GetMetadata("TargetPath")); 1083engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingRedistFile", t.RedistFiles[2].ItemSpec.Replace(t.RedistFiles[2].GetMetadata("SDKRootPath"), String.Empty), t.RedistFiles[2].GetMetadata("TargetPath")); 1084engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingRedistFile", t.RedistFiles[3].ItemSpec.Replace(t.RedistFiles[3].GetMetadata("SDKRootPath"), String.Empty), t.RedistFiles[3].GetMetadata("TargetPath")); 1085engine.AssertLogContainsMessageFromResource(_resourceDelegate, "GetSDKReferenceFiles.AddingRedistFile", t.RedistFiles[4].ItemSpec.Replace(t.RedistFiles[4].GetMetadata("SDKRootPath"), String.Empty), t.RedistFiles[4].GetMetadata("TargetPath")); 1368Assert.Equal("A.dll", Path.GetFileName(t.RedistFiles[0].ItemSpec), true); 1374Assert.Equal("B.dll", Path.GetFileName(t.RedistFiles[1].ItemSpec), true); 1380Assert.Equal("B.dll", Path.GetFileName(t.RedistFiles[2].ItemSpec), true); 1386Assert.Equal("B.pri", Path.GetFileName(t.RedistFiles[3].ItemSpec), true); 1392Assert.Equal("B.PRI", Path.GetFileName(t.RedistFiles[4].ItemSpec), true); 1398Assert.Equal("C.dll", Path.GetFileName(t.RedistFiles[5].ItemSpec), true); 1404Assert.Equal("D.dll", Path.GetFileName(t.RedistFiles[6].ItemSpec), true);

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

52Assert.Equal(destinationFile, t.DestinationFiles[0].ItemSpec); 99Assert.Equal(destinationFile, t.DestinationFiles[0].ItemSpec); 148Assert.Equal(destinationFile, t.DestinationFiles[0].ItemSpec); 468Assert.Equal(validOutFile, t.MovedFiles[0].ItemSpec); 473Assert.Equal(invalidFile, t.DestinationFiles[0].ItemSpec); 474Assert.Equal(validOutFile, t.DestinationFiles[1].ItemSpec); 475Assert.Equal(validOutFile, t.MovedFiles[0].ItemSpec); 631Assert.Equal(filename.ToLowerInvariant(), t.DestinationFiles[0].ItemSpec); 676Assert.Equal(file, t.DestinationFiles[0].ItemSpec); 677Assert.Equal(dest2, t.DestinationFiles[1].ItemSpec); 679Assert.Equal(file, t.MovedFiles[0].ItemSpec); 730Assert.Equal(destFile, t.DestinationFiles[0].ItemSpec); 731Assert.Equal(destFile, t.MovedFiles[0].ItemSpec);

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

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

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

118Assert.Equal(resolvedPath.ItemSpec, expectedPath); 199unresolvedOutputs[rvpo.UnresolvedProjectReferences[i].ItemSpec] = rvpo.UnresolvedProjectReferences[i]; 205resolvedOutputs[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);

71string resourcesFile = t.OutputResources[0].ItemSpec; 73resourcesFile = t.FilesWritten[0].ItemSpec; 89File.Delete(t.Sources[0].ItemSpec); 92if (File.Exists(item.ItemSpec)) 94File.Delete(item.ItemSpec); 137File.Delete(item.ItemSpec); 159string resourcesFile = t.OutputResources[0].ItemSpec; 161resourcesFile = t.FilesWritten[0].ItemSpec; 172File.Delete(t.Sources[0].ItemSpec); 175if (File.Exists(item.ItemSpec)) 177File.Delete(item.ItemSpec); 208resourcesFile = t.OutputResources[0].ItemSpec; 210Assert.Equal(t.FilesWritten[0].ItemSpec, resourcesFile); 247Assert.Equal(".resx", Path.GetExtension(t.FilesWritten[0].ItemSpec)); 254Assert.Equal(".txt", Path.GetExtension(t2a.FilesWritten[0].ItemSpec)); 258t2b.Sources = new ITaskItem[] { new TaskItem(t2a.FilesWritten[0].ItemSpec) }; 261Assert.Equal(".resx", Path.GetExtension(t2b.FilesWritten[0].ItemSpec)); 264Assert.Equal(Utilities.ReadFileContent(t.OutputResources[0].ItemSpec), 265Utilities.ReadFileContent(t2b.OutputResources[0].ItemSpec)); 266Utilities.AssertLogContainsResource(t2b, "GenerateResource.ProcessingFile", t2b.Sources[0].ItemSpec, t2b.OutputResources[0].ItemSpec); 267Utilities.AssertLogContainsResource(t2b, "GenerateResource.ReadResourceMessage", 4, t2b.Sources[0].ItemSpec); 271File.Delete(t.OutputResources[0].ItemSpec); 272File.Delete(t2a.OutputResources[0].ItemSpec); 275File.Delete(item.ItemSpec); 299resourcesFile = t.FilesWritten[0].ItemSpec; 302Utilities.AssertLogContainsResource(t, "GenerateResource.ProcessingFile", t.Sources[0].ItemSpec, outputFile); 303Utilities.AssertLogContainsResource(t, "GenerateResource.ReadResourceMessage", 4, t.Sources[0].ItemSpec); 306File.Delete(t.Sources[0].ItemSpec); 309File.Delete(item.ItemSpec); 331var resourceOutput = t.OutputResources[0].ItemSpec; 333Path.GetExtension(t.FilesWritten[0].ItemSpec).ShouldBe(".resources"); 346Utilities.AssertLogContainsResource(t, "GenerateResource.OutputDoesntExist", t.OutputResources[0].ItemSpec); 359File.GetLastAccessTime(t2.OutputResources[0].ItemSpec).ShouldBe(DateTime.Now, TimeSpan.FromSeconds(5)); 361Utilities.AssertLogContainsResource(t2, "GenerateResource.InputNewer", t2.Sources[0].ItemSpec, t2.OutputResources[0].ItemSpec); 376Utilities.AssertLogContainsResource(t, "GenerateResource.OutputDoesntExist", t.OutputResources[0].ItemSpec); 387Utilities.AssertLogContainsResource(t2, "GenerateResource.ResourceNotFound", t2.Sources[0].ItemSpec); 409Path.GetExtension(t.OutputResources[0].ItemSpec).ShouldBe(".resources"); 410Path.GetExtension(t.FilesWritten[0].ItemSpec).ShouldBe(".resources"); 418DateTime firstWriteTime = File.GetLastWriteTime(t.OutputResources[0].ItemSpec); 424File.GetLastWriteTime(t2.OutputResources[0].ItemSpec).ShouldBeGreaterThan(firstWriteTime); 431t2.OutputResources[0].ItemSpec); 436File.Delete(t.Sources[0].ItemSpec); 440if (File.Exists(item.ItemSpec)) 442File.Delete(item.ItemSpec); 475Path.GetExtension(t.OutputResources[0].ItemSpec).ShouldBe(".resources"); 479Utilities.ReadResourceValue(t.OutputResources[0].ItemSpec, "LinkedText").ShouldBe("original content"); 494Utilities.ReadResourceValue(t2.OutputResources[0].ItemSpec, "LinkedText").ShouldBe("updated content"); 511Utilities.AssertLogContainsResource(t1, "GenerateResource.OutputDoesntExist", t1.OutputResources[0].ItemSpec); 529File.Delete(output[0].ItemSpec); 533Utilities.AssertLogContainsResource(t3, "GenerateResource.ProcessingFile", sources[0].ItemSpec, output[0].ItemSpec); 540Utilities.AssertLogContainsResource(t4, "GenerateResource.OutputDoesntExist", t4.OutputResources[0].ItemSpec); 614File.Delete(t.Sources[0].ItemSpec); 619File.Delete(item.ItemSpec); 652File.Delete(t.Sources[0].ItemSpec); 656File.Delete(item.ItemSpec); 679Path.GetExtension(t.OutputResources[0].ItemSpec).ShouldBe(".resources"); 680Path.GetExtension(t.FilesWritten[0].ItemSpec).ShouldBe(".resources"); 703File.Delete(t.Sources[0].ItemSpec); 707if (File.Exists(item.ItemSpec)) 709File.Delete(item.ItemSpec); 735DateTime firstOutputCreationTime = File.GetLastWriteTime(createResources.OutputResources[0].ItemSpec); 736DateTime secondOutputCreationTime = File.GetLastWriteTime(createResources.OutputResources[1].ItemSpec); 740t2.StateFile = new TaskItem(createResources.StateFile.ItemSpec); 760File.GetLastWriteTime(t2.OutputResources[0].ItemSpec).ShouldBeGreaterThan(firstOutputCreationTime); 761File.GetLastWriteTime(t2.OutputResources[1].ItemSpec).ShouldBe(secondOutputCreationTime); 764t2.OutputResources[0].ItemSpec.ShouldBe(createResources.OutputResources[0].ItemSpec); 765t2.OutputResources[1].ItemSpec.ShouldBe(createResources.OutputResources[1].ItemSpec); 766t2.FilesWritten[0].ItemSpec.ShouldBe(createResources.FilesWritten[0].ItemSpec); 767t2.FilesWritten[1].ItemSpec.ShouldBe(createResources.FilesWritten[1].ItemSpec); 769Utilities.AssertLogContainsResource(t2, "GenerateResource.InputNewer", firstResx, t2.OutputResources[0].ItemSpec); 793string resourcesFile = t.OutputResources[0].ItemSpec; 795resourcesFile = t.FilesWritten[0].ItemSpec; 800DateTime time = File.GetLastWriteTime(t.OutputResources[0].ItemSpec); 810Assert.True(time.Equals(File.GetLastWriteTime(t2.OutputResources[0].ItemSpec))); 815File.Delete(t.Sources[0].ItemSpec); 819if (File.Exists(item.ItemSpec)) 821File.Delete(item.ItemSpec); 851Assert.Equal(t.OutputResources[0].ItemSpec, resourcesFile1); 852Assert.Equal(t.FilesWritten[0].ItemSpec, resourcesFile1); 853Assert.Equal(t.OutputResources[1].ItemSpec, resourcesFile2); 854Assert.Equal(t.FilesWritten[1].ItemSpec, resourcesFile2); 863DateTime time = File.GetLastWriteTime(t.OutputResources[0].ItemSpec); 864DateTime time2 = File.GetLastWriteTime(t.OutputResources[1].ItemSpec); 870Assert.Equal(t2.OutputResources[0].ItemSpec, resourcesFile1); 871Assert.Equal(t2.FilesWritten[0].ItemSpec, resourcesFile1); 872Assert.Equal(t2.OutputResources[1].ItemSpec, resourcesFile2); 873Assert.Equal(t2.FilesWritten[1].ItemSpec, resourcesFile2); 877Assert.True(time.Equals(File.GetLastWriteTime(t2.OutputResources[0].ItemSpec))); 878Assert.True(time2.Equals(File.GetLastWriteTime(t2.OutputResources[1].ItemSpec))); 933DateTime firstWriteTime = File.GetLastWriteTime(initialCreator.OutputResources[0].ItemSpec); 943File.GetLastWriteTime(incrementalUpToDate.OutputResources[0].ItemSpec).ShouldBe(firstWriteTime); 963File.GetLastWriteTime(incrementalOutOfDate.OutputResources[0].ItemSpec).ShouldBeGreaterThan(firstWriteTime); 965resourcesFile = incrementalOutOfDate.OutputResources[0].ItemSpec; 967Utilities.AssertLogContainsResource(incrementalOutOfDate, "GenerateResource.InputNewer", localSystemDll, incrementalOutOfDate.OutputResources[0].ItemSpec); 1010if (!File.Exists(file.ItemSpec)) 1012File.WriteAllText(file.ItemSpec, ""); 1032File.SetLastWriteTime(additionalInputs[1].ItemSpec, newTime); 1039Utilities.AssertLogContainsResource(t3, "GenerateResource.InputNewer", additionalInputs[1].ItemSpec, t3.OutputResources[0].ItemSpec); 1040resourcesFile = t3.OutputResources[0].ItemSpec; 1054if (additionalInputs?[0] != null && File.Exists(additionalInputs[0].ItemSpec)) 1056File.Delete(additionalInputs[0].ItemSpec); 1059if (additionalInputs?[1] != null && File.Exists(additionalInputs[1].ItemSpec)) 1061File.Delete(additionalInputs[1].ItemSpec); 1086string resourcesFile = t.OutputResources[0].ItemSpec; 1093File.Delete(t.Sources[0].ItemSpec); 1096File.Delete(item.ItemSpec); 1117Assert.Equal(".resx", Path.GetExtension(t.FilesWritten[0].ItemSpec)); 1121t2a.Sources = new ITaskItem[] { new TaskItem(t.FilesWritten[0].ItemSpec) }; 1122t2a.OutputResources = new ITaskItem[] { new TaskItem(Path.ChangeExtension(t.FilesWritten[0].ItemSpec, ".resources")) }; 1124Assert.Equal(".resources", Path.GetExtension(t2a.FilesWritten[0].ItemSpec)); 1128t2b.Sources = new ITaskItem[] { new TaskItem(t2a.FilesWritten[0].ItemSpec) }; 1130File.Delete(t2b.OutputResources[0].ItemSpec); 1132Assert.Equal(".resx", Path.GetExtension(t2b.FilesWritten[0].ItemSpec)); 1135Assert.Equal(Utilities.ReadFileContent(t.OutputResources[0].ItemSpec), 1136Utilities.ReadFileContent(t2b.OutputResources[0].ItemSpec)); 1140File.Delete(t.OutputResources[0].ItemSpec); 1141File.Delete(t2a.OutputResources[0].ItemSpec); 1144File.Delete(item.ItemSpec); 1167string resourcesFile = t.OutputResources[0].ItemSpec; 1178resourcesFile = t2.FilesWritten[0].ItemSpec; 1184File.Delete(t.Sources[0].ItemSpec); 1187File.Delete(item.ItemSpec); 1190File.Delete(t2.Sources[0].ItemSpec); 1193File.Delete(item.ItemSpec); 1213string resourcesFile = t.OutputResources[0].ItemSpec; 1215string stronglyTypedClassName = Path.GetFileNameWithoutExtension(t.OutputResources[0].ItemSpec); 1218resourcesFile = t.FilesWritten[0].ItemSpec; 1222string stronglyTypedFileName = Path.ChangeExtension(t.Sources[0].ItemSpec, ".cs"); 1223Assert.Equal(t.FilesWritten[2].ItemSpec, stronglyTypedFileName); 1246File.Delete(t.Sources[0].ItemSpec); 1250if (File.Exists(item.ItemSpec)) 1252File.Delete(item.ItemSpec); 1276string resourcesFile = t.OutputResources[0].ItemSpec; 1278string stronglyTypedClassName = Path.GetFileNameWithoutExtension(t.OutputResources[0].ItemSpec); 1281resourcesFile = t.FilesWritten[0].ItemSpec; 1286string stronglyTypedFileName = Path.ChangeExtension(t.Sources[0].ItemSpec, ".cs"); 1287Assert.Equal(t.FilesWritten[2].ItemSpec, stronglyTypedFileName); 1315Assert.Equal(t2.OutputResources[0].ItemSpec, resourcesFile); 1316Assert.Equal(t2.FilesWritten[0].ItemSpec, resourcesFile); 1319Assert.Equal(t2.FilesWritten[2].ItemSpec, Path.ChangeExtension(t2.Sources[0].ItemSpec, ".cs")); 1324File.Delete(t.Sources[0].ItemSpec); 1328if (File.Exists(item.ItemSpec)) 1330File.Delete(item.ItemSpec); 1335if (File.Exists(item.ItemSpec)) 1337File.Delete(item.ItemSpec); 1371resourcesFile = t.OutputResources[0].ItemSpec; 1374Assert.Equal(t.FilesWritten[2].ItemSpec, strFile); 1402Assert.Equal(t.OutputResources[0].ItemSpec, resourcesFile); 1404Assert.Equal(t.FilesWritten[2].ItemSpec, strFile); 1462resourcesFile = t.OutputResources[0].ItemSpec; 1465Assert.Equal(".resources", Path.GetExtension(t.FilesWritten[0].ItemSpec)); 1469Assert.Equal(t.FilesWritten[1].ItemSpec, strFile); 1474Utilities.AssertLogContainsResource(t, "GenerateResource.ProcessingFile", txtFile, t.OutputResources[0].ItemSpec); 1522string stronglyTypedFileName = Path.ChangeExtension(t.Sources[0].ItemSpec, ".vb"); 1523Assert.Equal(t.FilesWritten[2].ItemSpec, stronglyTypedFileName); 1525string resourcesFile = t.OutputResources[0].ItemSpec; 1527resourcesFile = t.FilesWritten[0].ItemSpec; 1553File.Delete(t.Sources[0].ItemSpec); 1557if (File.Exists(item.ItemSpec)) 1559File.Delete(item.ItemSpec); 1581string resourcesFile = t.OutputResources[0].ItemSpec; 1583resourcesFile = t.FilesWritten[0].ItemSpec; 1589string STRfile = Path.ChangeExtension(t.Sources[0].ItemSpec, ".cs"); 1594Assert.Equal(t.StronglyTypedClassName, Path.GetFileNameWithoutExtension(t.OutputResources[0].ItemSpec)); 1606File.Delete(t.Sources[0].ItemSpec); 1610if (File.Exists(item.ItemSpec)) 1612File.Delete(item.ItemSpec); 1639string resourcesFile = t.OutputResources[0].ItemSpec; 1641resourcesFile = t.FilesWritten[0].ItemSpec; 1647string STRfile = Path.ChangeExtension(t.Sources[0].ItemSpec, ".cs"); 1652Assert.Equal(t.StronglyTypedClassName, Path.GetFileNameWithoutExtension(t.OutputResources[0].ItemSpec)); 1676FileUtilities.DeleteNoThrow(item.ItemSpec); 1765File.Delete(t.Sources[0].ItemSpec); 1773FileUtilities.DeleteNoThrow(item.ItemSpec); 1823File.Delete(t.Sources[0].ItemSpec); 1831FileUtilities.DeleteNoThrow(item.ItemSpec); 1880File.Delete(t.Sources[0].ItemSpec); 1888FileUtilities.DeleteNoThrow(item.ItemSpec); 1925File.Delete(t.Sources[0].ItemSpec); 1933FileUtilities.DeleteNoThrow(item.ItemSpec); 1985File.Delete(t.Sources[0].ItemSpec); 1988File.Delete(item.ItemSpec); 2004File.Delete(t.Sources[0].ItemSpec); 2007File.Delete(item.ItemSpec); 2056Assert.Equal(t.OutputResources[0].ItemSpec, resourcesFile2); 2058Assert.Equal(t.FilesWritten[0].ItemSpec, resourcesFile2); 2135Assert.Equal(t.OutputResources[0].ItemSpec, resourcesFile2); 2137Assert.Equal(t.FilesWritten[0].ItemSpec, resourcesFile2); 2189File.Delete(t.Sources[0].ItemSpec); 2192File.Delete(item.ItemSpec); 2216File.Delete(t.Sources[0].ItemSpec); 2220File.Delete(item.ItemSpec); 2243resourcesFile = t.OutputResources[0].ItemSpec; 2245Assert.Equal(t.FilesWritten[0].ItemSpec, t.OutputResources[0].ItemSpec); 2331File.Delete(t.Sources[0].ItemSpec); 2334File.Delete(item.ItemSpec); 2387File.Delete(t.Sources[0].ItemSpec); 2391File.Delete(item.ItemSpec); 2471Assert.Equal("MyAlternateResource.resources", t.OutputResources[0].ItemSpec); 2477File.Delete(t.Sources[0].ItemSpec); 2480File.Delete(item.ItemSpec); 2501Assert.Equal(resourcesFile, t.OutputResources[0].ItemSpec); 2507File.Delete(t.Sources[0].ItemSpec); 2510File.Delete(item.ItemSpec); 2534string outputFile = Path.ChangeExtension(t.Sources[i].ItemSpec, ".resources"); 2535Assert.Equal(outputFile, t.OutputResources[i].ItemSpec); 2541File.Delete(item.ItemSpec); 2546File.Delete(item.ItemSpec); 2574Assert.Equal(t.FilesWritten[i].ItemSpec, t.OutputResources[i].ItemSpec); 2575Assert.True(File.Exists(t.FilesWritten[i].ItemSpec)); 2581File.Delete(t.StateFile.ItemSpec); 2584File.Delete(item.ItemSpec); 2588File.Delete(item.ItemSpec); 2611File.Delete(Path.ChangeExtension(taskItem.ItemSpec, ".resources")); 2620string outputFile = Path.ChangeExtension(t.Sources[0].ItemSpec, ".resources"); 2621Assert.Equal(outputFile, t.OutputResources[0].ItemSpec); 2622Assert.True(File.Exists(t.OutputResources[0].ItemSpec)); 2623outputFile = Path.ChangeExtension(t.Sources[1].ItemSpec, ".resources"); 2624Assert.Equal(outputFile, t.OutputResources[1].ItemSpec); 2625Assert.True(File.Exists(t.OutputResources[1].ItemSpec)); 2627outputFile = Path.ChangeExtension(t.Sources[2].ItemSpec, ".resources"); 2630outputFile = Path.ChangeExtension(t.Sources[3].ItemSpec, ".resources"); 2631Assert.Equal(outputFile, t.OutputResources[2].ItemSpec); 2632Assert.True(File.Exists(t.OutputResources[2].ItemSpec)); 2635Assert.Equal(t.FilesWritten[0].ItemSpec, Path.ChangeExtension(t.Sources[0].ItemSpec, ".resources")); 2636Assert.Equal(t.FilesWritten[1].ItemSpec, Path.ChangeExtension(t.Sources[1].ItemSpec, ".resources")); 2648Assert.Equal(t.FilesWritten[2].ItemSpec, Path.ChangeExtension(t.Sources[3].ItemSpec, ".resources")); 2662File.Delete(item.ItemSpec); 2666if (File.Exists(item.ItemSpec)) 2668File.Delete(item.ItemSpec); 2696Utilities.AssertLogContainsResource(t, "GenerateResource.ProcessingFile", textFile, t.OutputResources[0].ItemSpec); 2708File.Delete(t.Sources[0].ItemSpec); 2712if (File.Exists(item.ItemSpec)) 2714File.Delete(item.ItemSpec); 2733File.Delete(Path.ChangeExtension(t.Sources[0].ItemSpec, ".cs")); 2738Utilities.AssertLogContainsResource(t, "GenerateResource.ProcessingFile", textFile, t.OutputResources[0].ItemSpec); 2742Assert.Equal(t.StronglyTypedFileName, Path.ChangeExtension(t.Sources[0].ItemSpec, ".cs")); 2753File.Delete(t.Sources[0].ItemSpec); 2758if (File.Exists(item.ItemSpec)) 2760File.Delete(item.ItemSpec); 2794if (item.ItemSpec != null) 2796File.Delete(item.ItemSpec); 2856Assert.Equal(t.OutputResources[0].ItemSpec, resourcesFile); 2885File.SetAttributes(t.StateFile.ItemSpec, FileAttributes.ReadOnly); 2896File.Delete(t.Sources[0].ItemSpec); 2897File.SetAttributes(t.StateFile.ItemSpec, FileAttributes.Normal); 2902if (item.ItemSpec != null) 2904File.Delete(item.ItemSpec); 2931File.Delete(t.Sources[0].ItemSpec); 2936if (item.ItemSpec != null) 2938File.Delete(item.ItemSpec); 2963File.Delete(t.Sources[0].ItemSpec); 2968if (item.ItemSpec != null) 2970File.Delete(item.ItemSpec); 2995File.Delete(t.Sources[0].ItemSpec); 3000if (item.ItemSpec != null) 3002File.Delete(item.ItemSpec); 3027File.Delete(t.Sources[0].ItemSpec); 3032if (item.ItemSpec != null) 3034File.Delete(item.ItemSpec); 3898string resourcesFile = t.OutputResources[0].ItemSpec; 3900resourcesFile = t.FilesWritten[0].ItemSpec; 3920File.Delete(t.Sources[0].ItemSpec); 3923if (File.Exists(item.ItemSpec)) 3925File.Delete(item.ItemSpec); 3955string outputResourceFile = task.OutputResources[0].ItemSpec; 3956task.OutputResources[0].ItemSpec.ShouldBe(task.FilesWritten[0].ItemSpec); 3963string resourcesFile = t.OutputResources[0].ItemSpec; 3972resourcesFile = t.OutputResources[0].ItemSpec; 4113Assert.True(File.Exists(t.StateFile.ItemSpec)); // "State file should exist" 4120if (t.StateFile.ItemSpec.Equals(t.FilesWritten[i].ItemSpec)) 4152return t.OutputResources[0].ItemSpec; 4172File.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}"); 4525string resourcesFile = t.OutputResources[0].ItemSpec; 4528Assert.Equal(Path.GetFileNameWithoutExtension(textFile), Path.GetFileNameWithoutExtension(t.OutputResources[0].ItemSpec)); 4531string stronglyTypedClassName = Path.GetFileNameWithoutExtension(t.OutputResources[0].ItemSpec); 4538resourcesFile = t.FilesWritten[0].ItemSpec; 4544Assert.Equal(Path.ChangeExtension(t.Sources[0].ItemSpec, codeFileExtension), t.StronglyTypedFileName); 4545Assert.Equal(t.FilesWritten[2].ItemSpec, t.StronglyTypedFileName); 4585File.Delete(t.Sources[0].ItemSpec); 4589if (File.Exists(item.ItemSpec)) 4591File.Delete(item.ItemSpec);

95Assert.Equal(file, task.OutputFile.ItemSpec); 98File.Delete(task.OutputFile.ItemSpec); 120Assert.Equal(expectedFile, task.OutputFile.ItemSpec); 140Assert.Equal(file.ItemSpec, task.OutputFile.ItemSpec); 141Assert.True(File.Exists(task.OutputFile.ItemSpec)); 165Assert.Equal(fileName, task.OutputFile.ItemSpec); 191Assert.Equal(file, task.OutputFile.ItemSpec); 343string content = File.ReadAllText(task.OutputFile.ItemSpec); 370string content = File.ReadAllText(task.OutputFile.ItemSpec); 396Assert.True(File.Exists(task.OutputFile.ItemSpec)); 397Assert.Equal(Path.GetTempPath(), task.OutputFile.ItemSpec.Substring(0, Path.GetTempPath().Length)); 398Assert.Equal(".cs", task.OutputFile.ItemSpec.Substring(task.OutputFile.ItemSpec.Length - 3)); 400File.Delete(task.OutputFile.ItemSpec); 419Assert.True(File.Exists(task.OutputFile.ItemSpec)); 420Assert.Equal(folder.ItemSpec, task.OutputFile.ItemSpec.Substring(0, folder.ItemSpec.Length)); 421Assert.Equal(".cs", task.OutputFile.ItemSpec.Substring(task.OutputFile.ItemSpec.Length - 3)); 455Path.IsPathRooted(task.OutputFile.ItemSpec).ShouldBeFalse("OutputFile should be relative when OutputDirectory is relative"); 458task.OutputFile.ItemSpec.ShouldStartWith(relativeFolder); 461string absoluteOutputFile = Path.Combine(Path.GetDirectoryName(absoluteFolder), task.OutputFile.ItemSpec); 529File.Delete(task.OutputFile.ItemSpec); 577string content = File.ReadAllText(task.OutputFile.ItemSpec); 582File.Delete(task.OutputFile.ItemSpec); 602string content = File.ReadAllText(task.OutputFile.ItemSpec); 607File.Delete(task.OutputFile.ItemSpec); 635string content = File.ReadAllText(task.OutputFile.ItemSpec); 641File.Delete(task.OutputFile.ItemSpec); 672string content = File.ReadAllText(task.OutputFile.ItemSpec); 681File.Delete(task.OutputFile.ItemSpec); 779string content = File.ReadAllText(task.OutputFile.ItemSpec); 787File.Delete(task.OutputFile.ItemSpec); 813string content = File.ReadAllText(task.OutputFile.ItemSpec); 818File.Delete(task.OutputFile.ItemSpec); 1202string content = File.ReadAllText(task.OutputFile.ItemSpec); 1216if ((task.OutputFile is not null) && File.Exists(task.OutputFile.ItemSpec)) 1218File.Delete(task.OutputFile.ItemSpec); 1240if ((task.OutputFile is not null) && File.Exists(task.OutputFile.ItemSpec)) 1242File.Delete(task.OutputFile.ItemSpec); 1310string content = File.ReadAllText(task.OutputFile.ItemSpec); 1324if (task.OutputFile != null && File.Exists(task.OutputFile.ItemSpec)) 1326File.Delete(task.OutputFile.ItemSpec);

48Assert.False(File.Exists(a.File.ItemSpec)); 77Assert.Equal("\uBDEA", r.Lines[0].ItemSpec); 100Assert.NotEqual("\uBDEA", r.Lines[0].ItemSpec); 130r.Lines[0].ItemSpec.ShouldBe("File contents1"); 217r.Lines[0].ItemSpec.ShouldBe("File contents1");

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

377using (StreamReader sr = new StreamReader(t.OutputPaths[0].ItemSpec)) 414using (StreamReader sr = new StreamReader(t.OutputPaths[0].ItemSpec)) 889using (StreamReader sr = new StreamReader(t.OutputPaths[0].ItemSpec))

362expectedItemSpecs.Append(expectedItem.ItemSpec); 374actualItemSpecs.Append(actualItem.ItemSpec); 389if (expectedItems[expectedItemIndex].ItemSpec == actualItem.ItemSpec) 419string.Format("Item '{0}' does not have expected metadata '{1}'.", actualItem.ItemSpec, metadataName)); 423string.Format("Item '{0}' has unexpected metadata {1}={2}.", actualItem.ItemSpec, metadataName, actualMetadataValue)); 443Assert.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);

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

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

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

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

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

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

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

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

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

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

504if (Enum.TryParse(item.ItemSpec, true, out ArtifactVisibility parsedVisibility)) 510throw 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('\\', '/');

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

290if (PdbFile != null && !string.IsNullOrEmpty(PdbFile.ItemSpec)) 292PdbFile.ItemSpec = Path.Combine("%outputfolder%", Path.GetFileName(PdbFile.ItemSpec)); 296if (BindTrackingFile != null && !string.IsNullOrEmpty(BindTrackingFile.ItemSpec)) 298BindTrackingFile.ItemSpec = Path.Combine("%outputfolder%", Path.GetFileName(BindTrackingFile.ItemSpec)); 321if (PdbFile != null && !string.IsNullOrEmpty(PdbFile.ItemSpec)) 323commandLineArgs.Add($"-pdb {PdbFile.ItemSpec}"); 375commandLineArgs.Add($"-ext {extension.ItemSpec}"); 384commandLineArgs.Add($"-loc {localizationFile.ItemSpec}"); 397commandLineArgs.Add($"-bindPath {bindPath.ItemSpec}"); 398commandLineArgs.Add($"-bindPath {bindName}={bindPath.ItemSpec}"); 404commandLineArgs.Add($"-intermediatefolder {IntermediateDirectory.ItemSpec}"); 407if (BindTrackingFile != null && !string.IsNullOrEmpty(BindTrackingFile.ItemSpec)) 409commandLineArgs.Add($"-trackingfile {BindTrackingFile.ItemSpec}"); 426commandLineArgs.Add($"{Path.GetFileName(sourceFile.ItemSpec)}"); 510var xmlPath = GetAbsoluteSourcePath(sourceFile.ItemSpec); 513Log.LogError($"Source file not found: {sourceFile.ItemSpec}"); 1037var extensionPath = Extensions[i].ItemSpec; 1055string bindPath = BindPaths[i].ItemSpec; 1080var localizationPath = LocalizationFiles[i].ItemSpec;

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

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

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

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;

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

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)

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

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

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

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

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

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

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

541_escapedItemSpec = EscapingUtilities.Escape(copyFrom.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))

168string resourcesFile = OutputResourcesFile[0].ItemSpec; 177string resFileName = resourceFile.ItemSpec; 291strFileName = inputFile.ItemSpec; 314resFile.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))

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

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