Move VerifyClosure tasks into M.D.PackageTesting (#7692)

ViktorHofer · web-flow · commit a50c27610c6a · 2021-08-02T12:35:29.000+02:00
As we plan to deprecate the M.D.B.Tasks.Packaging project in the future, moving the tasks into the PackageTesting project. Fixes #7474
diff --git a/src/Microsoft.DotNet.Build.Tasks.Packaging/src/Microsoft.DotNet.Build.Tasks.Packaging.csproj b/src/Microsoft.DotNet.Build.Tasks.Packaging/src/Microsoft.DotNet.Build.Tasks.Packaging.csproj
@@ -38,9 +38,7 @@
 - SplitDependenciesBySupport
 - SplitReferences
 - UpdatePackageIndex
-- ValidationTask
-- VerifyClosure
-- VerifyTypes</PackageDescription>
+- ValidationTask</PackageDescription>
 
     <DefaultItemExcludes Condition="'$(TargetFramework)' != 'net472'">**/*.Desktop.*</DefaultItemExcludes>
     <BeforePack>$(BeforePack);AddRuntimeJson</BeforePack>
diff --git a/src/Microsoft.DotNet.Build.Tasks.Packaging/src/build/Packaging.common.targets b/src/Microsoft.DotNet.Build.Tasks.Packaging/src/build/Packaging.common.targets
@@ -44,7 +44,5 @@
   <UsingTask TaskName="UpdatePackageIndex" AssemblyFile="$(PackagingTaskDir)Microsoft.DotNet.Build.Tasks.Packaging.dll"/>
   <UsingTask TaskName="ValidatePackage" AssemblyFile="$(PackagingTaskDir)Microsoft.DotNet.Build.Tasks.Packaging.dll"/>
   <UsingTask TaskName="ValidateFrameworkPackage" AssemblyFile="$(PackagingTaskDir)Microsoft.DotNet.Build.Tasks.Packaging.dll"/>
-  <UsingTask TaskName="VerifyClosure" AssemblyFile="$(PackagingTaskDir)Microsoft.DotNet.Build.Tasks.Packaging.dll"/>
-  <UsingTask TaskName="VerifyTypes" AssemblyFile="$(PackagingTaskDir)Microsoft.DotNet.Build.Tasks.Packaging.dll"/>
   <UsingTask TaskName="GetSupportedPackagesFromPackageReports" AssemblyFile="$(PackagingTaskDir)Microsoft.DotNet.Build.Tasks.Packaging.dll"/>
 </Project>
diff --git a/src/Microsoft.DotNet.PackageTesting.Tests/Microsoft.DotNet.PackageTesting.Tests.csproj b/src/Microsoft.DotNet.PackageTesting.Tests/Microsoft.DotNet.PackageTesting.Tests.csproj
@@ -9,6 +9,8 @@
     <PackageReference Include="Microsoft.Build.Utilities.Core" Version="$(MicrosoftBuildUtilitiesCoreVersion)" />
     <PackageReference Include="NuGet.Frameworks" Version="$(NuGetVersion)" />
     <PackageReference Include="NuGet.Packaging" Version="$(NuGetVersion)" />
+    <!-- Remove when targeting >= net5.0. -->
+    <PackageReference Include="System.Reflection.Metadata" Version="5.0.0" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/src/Microsoft.DotNet.PackageTesting/GetCompatiblePackageTargetFrameworks.cs b/src/Microsoft.DotNet.PackageTesting/GetCompatiblePackageTargetFrameworks.cs
@@ -13,7 +13,7 @@ namespace Microsoft.DotNet.PackageTesting
 {
     public class GetCompatiblePackageTargetFrameworks : BuildTask
     {
-        private static List<NuGetFramework> allTargetFrameworks = allTargetFrameworks = new();
+        private static List<NuGetFramework> allTargetFrameworks = new();
         private static Dictionary<NuGetFramework, HashSet<NuGetFramework>> packageTfmMapping = new();
 
         [Required]
@@ -27,12 +27,15 @@ public class GetCompatiblePackageTargetFrameworks : BuildTask
 
         public override bool Execute()
         {
-            bool result = true;
-            List<ITaskItem> testProjects = new List<ITaskItem>();
+            List<ITaskItem> testProjects = new();
+
             try
             {
                 Initialize(SupportedTestFrameworks);
-                string minDotnetTargetFramework = allTargetFrameworks.Where(t => t.Framework == ".NETCoreApp").OrderBy(t => t.Version).FirstOrDefault()?.GetShortFolderName();
+                string minDotnetTargetFramework = allTargetFrameworks.Where(t => t.Framework == ".NETCoreApp")
+                    .OrderBy(t => t.Version)
+                    .FirstOrDefault()?
+                    .GetShortFolderName();
 
                 foreach (var packagePath in PackagePaths)
                 {
@@ -50,25 +53,30 @@ public override bool Execute()
                 Log.LogErrorFromException(e, showStackTrace: false);
             }
 
-            return result && !Log.HasLoggedErrors;
+            return !Log.HasLoggedErrors;
         }
 
         public static IEnumerable<NuGetFramework> GetTestFrameworks(Package package, string minDotnetTargetFramework)
         {
-            List<NuGetFramework> frameworksToTest= new List<NuGetFramework>();
+            List<NuGetFramework> frameworksToTest= new();
             IEnumerable<NuGetFramework> packageTargetFrameworks = package.FrameworksInPackage;
 
             // Testing the package installation on all tfms linked with package targetframeworks.
             foreach (var item in packageTargetFrameworks)
             {
                 if (packageTfmMapping.ContainsKey(item))
+                {
                     frameworksToTest.AddRange(packageTfmMapping[item]);
+                }
+
                 // Adding the frameworks in the packages to the test matrix.
                 frameworksToTest.Add(item);
             }
 
             if (!string.IsNullOrEmpty(minDotnetTargetFramework) && frameworksToTest.Any(t => t.Framework == ".NETStandard"))
+            {
                 frameworksToTest.Add(NuGetFramework.Parse(minDotnetTargetFramework));
+            }
 
             return frameworksToTest.Where(tfm => allTargetFrameworks.Contains(tfm)).Distinct();
         }
@@ -97,12 +105,12 @@ public static void Initialize(string targetFrameworks)
             }
         }
 
-        public List<ITaskItem> CreateItemFromTestFramework(string packageId, string version, IEnumerable<NuGetFramework> testFrameworks)
+        private static List<ITaskItem> CreateItemFromTestFramework(string packageId, string version, IEnumerable<NuGetFramework> testFrameworks)
         {
-            List<ITaskItem> testprojects = new List<ITaskItem>();
+            List<ITaskItem> testprojects = new();
             foreach (var framework in testFrameworks)
             {
-                var supportedPackage = new TaskItem(packageId);
+                TaskItem supportedPackage = new(packageId);
                 supportedPackage.SetMetadata("Version", version);
                 supportedPackage.SetMetadata("TargetFramework", framework.ToString());
                 supportedPackage.SetMetadata("TargetFrameworkShort", framework.GetShortFolderName());
diff --git a/src/Microsoft.DotNet.PackageTesting/Microsoft.DotNet.PackageTesting.csproj b/src/Microsoft.DotNet.PackageTesting/Microsoft.DotNet.PackageTesting.csproj
@@ -2,7 +2,6 @@
 
   <PropertyGroup>
     <TargetFrameworks>netcoreapp3.1;net472</TargetFrameworks>
-    <ExcludeFromSourceBuild>false</ExcludeFromSourceBuild>
     <PackageType>MSBuildSdk</PackageType>
     <IncludeBuildOutput>false</IncludeBuildOutput>
     <IsPackable>true</IsPackable>
diff --git a/src/Microsoft.DotNet.PackageTesting/NupkgParser.cs b/src/Microsoft.DotNet.PackageTesting/NupkgParser.cs
@@ -2,24 +2,29 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Linq;
+using System.Collections.Generic;
 using NuGet.Frameworks;
 using NuGet.Packaging;
 
 namespace Microsoft.DotNet.PackageTesting
 {
-    public class NupkgParser
+    class NupkgParser
     {
         public static Package CreatePackageObject(string packagePath)
         {
-            PackageArchiveReader nupkgReader = new PackageArchiveReader(packagePath);
+            PackageArchiveReader nupkgReader = new(packagePath);
             NuspecReader nuspecReader = nupkgReader.NuspecReader;
 
             string packageId = nuspecReader.GetId();
             string version = nuspecReader.GetVersion().ToString();
 
-            NuGetFramework[] dependencyFrameworks = nuspecReader.GetDependencyGroups().Select(dg => dg.TargetFramework).Where(tfm => tfm != null).ToArray();
+            NuGetFramework[] dependencyFrameworks = nuspecReader.GetDependencyGroups()
+                .Select(dg => dg.TargetFramework)
+                .Where(tfm => tfm != null)
+                .ToArray();
+            IEnumerable<string> files = nupkgReader.GetFiles()?.Where(t => t.EndsWith(packageId + ".dll"));
 
-            return new Package(packageId, version, nupkgReader.GetFiles()?.Where(t => t.EndsWith(packageId + ".dll")), dependencyFrameworks);
+            return new Package(packageId, version, files, dependencyFrameworks);
         }
     }
 }
diff --git a/src/Microsoft.DotNet.PackageTesting/Package.cs b/src/Microsoft.DotNet.PackageTesting/Package.cs
@@ -11,14 +11,18 @@ namespace Microsoft.DotNet.PackageTesting
 {
     public class Package
     {
+        public IEnumerable<NuGetFramework> FrameworksInPackage { get; }
+        public string PackageId { get; }
+        public string Version { get; }
+
         public Package(string packageId, string version, IEnumerable<string> packageAssetPaths, IEnumerable<NuGetFramework> dependencyFrameworks)
         {
             PackageId = packageId;
             Version = version;
 
             ContentItemCollection packageAssets = new();
             packageAssets.Load(packageAssetPaths);
-            ManagedCodeConventions conventions = new ManagedCodeConventions(null);
+            ManagedCodeConventions conventions = new(null);
 
             IEnumerable<ContentItem> RefAssets = packageAssets.FindItems(conventions.Patterns.CompileRefAssemblies);
             IEnumerable<ContentItem> LibAssets = packageAssets.FindItems(conventions.Patterns.CompileLibAssemblies);
@@ -30,9 +34,5 @@ public Package(string packageId, string version, IEnumerable<string> packageAsse
             FrameworksInPackageList.AddRange(dependencyFrameworks);
             FrameworksInPackage = FrameworksInPackageList.Distinct();
         }
-
-        public string PackageId { get; set; }
-        public string Version { get; set; }
-        public IEnumerable<NuGetFramework> FrameworksInPackage { get; private set; }
     }
 }
diff --git a/src/Microsoft.DotNet.PackageTesting/VerifyClosure.cs b/src/Microsoft.DotNet.PackageTesting/VerifyClosure.cs
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using Microsoft.Build.Framework;
+using Microsoft.DotNet.Build.Tasks;
 using System;
 using System.Collections.Generic;
 using System.IO;
@@ -12,7 +13,7 @@
 using System.Text;
 using System.Xml.Linq;
 
-namespace Microsoft.DotNet.Build.Tasks.Packaging
+namespace Microsoft.DotNet.PackageTesting
 {
     /// <summary>
     /// Verifies the closure of a set of DLLs, making sure all files are present and no cycles exist
@@ -125,7 +126,7 @@ private void AddSourceFile(string file)
 
         private void LoadIgnoredReferences()
         {
-            foreach (var ignoredReference in IgnoredReferences.NullAsEmpty())
+            foreach (var ignoredReference in IgnoredReferences.DefaultIfEmpty())
             {
                 var name = ignoredReference.ItemSpec;
                 var versionString = ignoredReference.GetMetadata("Version");
@@ -175,7 +176,7 @@ void CheckDependencies(Stack<AssemblyInfo> depStack)
             // check module references
             if (assm.State == CheckState.Unchecked && CheckModuleReferences)
             {
-                foreach(var moduleReference in assm.ModuleReferences.NullAsEmpty())
+                foreach(var moduleReference in assm.ModuleReferences.DefaultIfEmpty())
                 {
                     if (ShouldIgnore(moduleReference))
                     {
diff --git a/src/Microsoft.DotNet.PackageTesting/VerifyTypes.cs b/src/Microsoft.DotNet.PackageTesting/VerifyTypes.cs
@@ -2,21 +2,22 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using Microsoft.Build.Framework;
+using Microsoft.DotNet.Build.Tasks;
 using System;
 using System.Collections.Generic;
 using System.IO;
+using System.Linq;
 using System.Reflection;
 using System.Reflection.Metadata;
 using System.Reflection.PortableExecutable;
 
-namespace Microsoft.DotNet.Build.Tasks.Packaging
+namespace Microsoft.DotNet.PackageTesting
 {
     /// <summary>
     /// Verifies no type overlap in a set of DLLs
     /// </summary>
     public class VerifyTypes : BuildTask
     {
-
         /// <summary>
         /// Sources to scan.  Items can be directories or files.
         /// </summary>
@@ -124,7 +125,7 @@ private void AddSourceFile(string file)
 
         private void LoadIgnoredTypes()
         {
-            foreach(var ignoredType in IgnoredTypes.NullAsEmpty())
+            foreach(var ignoredType in IgnoredTypes.DefaultIfEmpty())
             {
                 ignoredTypes.Add(ignoredType.ItemSpec);
             }
diff --git a/src/Microsoft.DotNet.PackageTesting/build/Microsoft.DotNet.PackageTesting.props b/src/Microsoft.DotNet.PackageTesting/build/Microsoft.DotNet.PackageTesting.props
@@ -4,6 +4,10 @@
     <DotNetPackageTestingAssembly Condition="'$(MSBuildRuntimeType)' == 'Core'">$(MSBuildThisFileDirectory)..\tools\netcoreapp3.1\Microsoft.DotNet.PackageTesting.dll</DotNetPackageTestingAssembly>
   </PropertyGroup>
 
+  <UsingTask TaskName="GetCompatiblePackageTargetFrameworks" AssemblyFile="$(DotNetPackageTestingAssembly)" />
+  <UsingTask TaskName="VerifyClosure" AssemblyFile="$(DotNetPackageTestingAssembly)" />
+  <UsingTask TaskName="VerifyTypes" AssemblyFile="$(DotNetPackageTestingAssembly)"/>
+
   <ItemGroup>
     <SupportedTestFramework Include="netcoreapp3.1" />
     <SupportedTestFramework Include="net5.0" />
diff --git a/src/Microsoft.DotNet.SharedFramework.Sdk/Microsoft.DotNet.SharedFramework.Sdk.csproj b/src/Microsoft.DotNet.SharedFramework.Sdk/Microsoft.DotNet.SharedFramework.Sdk.csproj
@@ -41,8 +41,8 @@
   </ItemGroup>
 
   <ItemGroup>
-    <Compile Include="..\Microsoft.DotNet.Build.Tasks.Packaging\src\VerifyClosure.cs" Link="src/Packaging/VerifyClosure.cs" />
-    <Compile Include="..\Microsoft.DotNet.Build.Tasks.Packaging\src\VerifyTypes.cs" Link="src/Packaging/VerifyTypes.cs" />
+    <Compile Include="..\Microsoft.DotNet.PackageTesting\VerifyClosure.cs" Link="src/Packaging/VerifyClosure.cs" />
+    <Compile Include="..\Microsoft.DotNet.PackageTesting\VerifyTypes.cs" Link="src/Packaging/VerifyTypes.cs" />
   </ItemGroup>
   
   <ItemGroup Condition="'$(TargetFramework)' == 'net472'">
diff --git a/src/Microsoft.DotNet.SharedFramework.Sdk/src/Packaging/Extensions.cs b/src/Microsoft.DotNet.SharedFramework.Sdk/src/Packaging/Extensions.cs

Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,7 @@ namespace Microsoft.DotNet.PackageTesting`
`13`	`13`	`{`
`14`	`14`	`public class GetCompatiblePackageTargetFrameworks : BuildTask`
`15`	`15`	`{`
`16`		`- private static List<NuGetFramework> allTargetFrameworks = allTargetFrameworks = new();`
	`16`	`+ private static List<NuGetFramework> allTargetFrameworks = new();`
`17`	`17`	`private static Dictionary<NuGetFramework, HashSet<NuGetFramework>> packageTfmMapping = new();`
`18`	`18`
`19`	`19`	`[Required]`
`@@ -27,12 +27,15 @@ public class GetCompatiblePackageTargetFrameworks : BuildTask`
`27`	`27`
`28`	`28`	`public override bool Execute()`
`29`	`29`	`{`
`30`		`- bool result = true;`
`31`		`- List<ITaskItem> testProjects = new List<ITaskItem>();`
	`30`	`+ List<ITaskItem> testProjects = new();`
	`31`	`+`
`32`	`32`	`try`
`33`	`33`	`{`
`34`	`34`	`Initialize(SupportedTestFrameworks);`
`35`		`- string minDotnetTargetFramework = allTargetFrameworks.Where(t => t.Framework == ".NETCoreApp").OrderBy(t => t.Version).FirstOrDefault()?.GetShortFolderName();`
	`35`	`+ string minDotnetTargetFramework = allTargetFrameworks.Where(t => t.Framework == ".NETCoreApp")`
	`36`	`+ .OrderBy(t => t.Version)`
	`37`	`+ .FirstOrDefault()?`
	`38`	`+ .GetShortFolderName();`
`36`	`39`
`37`	`40`	`foreach (var packagePath in PackagePaths)`
`38`	`41`	`{`
`@@ -50,25 +53,30 @@ public override bool Execute()`
`50`	`53`	`Log.LogErrorFromException(e, showStackTrace: false);`
`51`	`54`	`}`
`52`	`55`
`53`		`- return result && !Log.HasLoggedErrors;`
	`56`	`+ return !Log.HasLoggedErrors;`
`54`	`57`	`}`
`55`	`58`
`56`	`59`	`public static IEnumerable<NuGetFramework> GetTestFrameworks(Package package, string minDotnetTargetFramework)`
`57`	`60`	`{`
`58`		`- List<NuGetFramework> frameworksToTest= new List<NuGetFramework>();`
	`61`	`+ List<NuGetFramework> frameworksToTest= new();`
`59`	`62`	`IEnumerable<NuGetFramework> packageTargetFrameworks = package.FrameworksInPackage;`
`60`	`63`
`61`	`64`	`// Testing the package installation on all tfms linked with package targetframeworks.`
`62`	`65`	`foreach (var item in packageTargetFrameworks)`
`63`	`66`	`{`
`64`	`67`	`if (packageTfmMapping.ContainsKey(item))`
	`68`	`+ {`
`65`	`69`	`frameworksToTest.AddRange(packageTfmMapping[item]);`
	`70`	`+ }`
	`71`	`+`
`66`	`72`	`// Adding the frameworks in the packages to the test matrix.`
`67`	`73`	`frameworksToTest.Add(item);`
`68`	`74`	`}`
`69`	`75`
`70`	`76`	`if (!string.IsNullOrEmpty(minDotnetTargetFramework) && frameworksToTest.Any(t => t.Framework == ".NETStandard"))`
	`77`	`+ {`
`71`	`78`	`frameworksToTest.Add(NuGetFramework.Parse(minDotnetTargetFramework));`
	`79`	`+ }`
`72`	`80`
`73`	`81`	`return frameworksToTest.Where(tfm => allTargetFrameworks.Contains(tfm)).Distinct();`
`74`	`82`	`}`
`@@ -97,12 +105,12 @@ public static void Initialize(string targetFrameworks)`
`97`	`105`	`}`
`98`	`106`	`}`
`99`	`107`
`100`		`- public List<ITaskItem> CreateItemFromTestFramework(string packageId, string version, IEnumerable<NuGetFramework> testFrameworks)`
	`108`	`+ private static List<ITaskItem> CreateItemFromTestFramework(string packageId, string version, IEnumerable<NuGetFramework> testFrameworks)`
`101`	`109`	`{`
`102`		`- List<ITaskItem> testprojects = new List<ITaskItem>();`
	`110`	`+ List<ITaskItem> testprojects = new();`
`103`	`111`	`foreach (var framework in testFrameworks)`
`104`	`112`	`{`
`105`		`- var supportedPackage = new TaskItem(packageId);`
	`113`	`+ TaskItem supportedPackage = new(packageId);`
`106`	`114`	`supportedPackage.SetMetadata("Version", version);`
`107`	`115`	`supportedPackage.SetMetadata("TargetFramework", framework.ToString());`
`108`	`116`	`supportedPackage.SetMetadata("TargetFrameworkShort", framework.GetShortFolderName());`
Original file line number	Diff line number	Diff line change
`@@ -2,24 +2,29 @@`
`2`	`2`	`// The .NET Foundation licenses this file to you under the MIT license.`
`3`	`3`
`4`	`4`	`using System.Linq;`
	`5`	`+using System.Collections.Generic;`
`5`	`6`	`using NuGet.Frameworks;`
`6`	`7`	`using NuGet.Packaging;`
`7`	`8`
`8`	`9`	`namespace Microsoft.DotNet.PackageTesting`
`9`	`10`	`{`
`10`		`- public class NupkgParser`
	`11`	`+ class NupkgParser`
`11`	`12`	`{`
`12`	`13`	`public static Package CreatePackageObject(string packagePath)`
`13`	`14`	`{`
`14`		`- PackageArchiveReader nupkgReader = new PackageArchiveReader(packagePath);`
	`15`	`+ PackageArchiveReader nupkgReader = new(packagePath);`
`15`	`16`	`NuspecReader nuspecReader = nupkgReader.NuspecReader;`
`16`	`17`
`17`	`18`	`string packageId = nuspecReader.GetId();`
`18`	`19`	`string version = nuspecReader.GetVersion().ToString();`
`19`	`20`
`20`		`- NuGetFramework[] dependencyFrameworks = nuspecReader.GetDependencyGroups().Select(dg => dg.TargetFramework).Where(tfm => tfm != null).ToArray();`
	`21`	`+ NuGetFramework[] dependencyFrameworks = nuspecReader.GetDependencyGroups()`
	`22`	`+ .Select(dg => dg.TargetFramework)`
	`23`	`+ .Where(tfm => tfm != null)`
	`24`	`+ .ToArray();`
	`25`	`+ IEnumerable<string> files = nupkgReader.GetFiles()?.Where(t => t.EndsWith(packageId + ".dll"));`
`21`	`26`
`22`		`- return new Package(packageId, version, nupkgReader.GetFiles()?.Where(t => t.EndsWith(packageId + ".dll")), dependencyFrameworks);`
	`27`	`+ return new Package(packageId, version, files, dependencyFrameworks);`
`23`	`28`	`}`
`24`	`29`	`}`
`25`	`30`	`}`
Original file line number	Diff line number	Diff line change
`@@ -11,14 +11,18 @@ namespace Microsoft.DotNet.PackageTesting`
`11`	`11`	`{`
`12`	`12`	`public class Package`
`13`	`13`	`{`
	`14`	`+ public IEnumerable<NuGetFramework> FrameworksInPackage { get; }`
	`15`	`+ public string PackageId { get; }`
	`16`	`+ public string Version { get; }`
	`17`	`+`
`14`	`18`	`public Package(string packageId, string version, IEnumerable<string> packageAssetPaths, IEnumerable<NuGetFramework> dependencyFrameworks)`
`15`	`19`	`{`
`16`	`20`	`PackageId = packageId;`
`17`	`21`	`Version = version;`
`18`	`22`
`19`	`23`	`ContentItemCollection packageAssets = new();`
`20`	`24`	`packageAssets.Load(packageAssetPaths);`
`21`		`- ManagedCodeConventions conventions = new ManagedCodeConventions(null);`
	`25`	`+ ManagedCodeConventions conventions = new(null);`
`22`	`26`
`23`	`27`	`IEnumerable<ContentItem> RefAssets = packageAssets.FindItems(conventions.Patterns.CompileRefAssemblies);`
`24`	`28`	`IEnumerable<ContentItem> LibAssets = packageAssets.FindItems(conventions.Patterns.CompileLibAssemblies);`
`@@ -30,9 +34,5 @@ public Package(string packageId, string version, IEnumerable<string> packageAsse`
`30`	`34`	`FrameworksInPackageList.AddRange(dependencyFrameworks);`
`31`	`35`	`FrameworksInPackage = FrameworksInPackageList.Distinct();`
`32`	`36`	`}`
`33`		`-`
`34`		`- public string PackageId { get; set; }`
`35`		`- public string Version { get; set; }`
`36`		`- public IEnumerable<NuGetFramework> FrameworksInPackage { get; private set; }`
`37`	`37`	`}`
`38`	`38`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2,6 +2,7 @@`
`2`	`2`	`// The .NET Foundation licenses this file to you under the MIT license.`
`3`	`3`
`4`	`4`	`using Microsoft.Build.Framework;`
	`5`	`+using Microsoft.DotNet.Build.Tasks;`
`5`	`6`	`using System;`
`6`	`7`	`using System.Collections.Generic;`
`7`	`8`	`using System.IO;`
`@@ -12,7 +13,7 @@`
`12`	`13`	`using System.Text;`
`13`	`14`	`using System.Xml.Linq;`
`14`	`15`
`15`		`-namespace Microsoft.DotNet.Build.Tasks.Packaging`
	`16`	`+namespace Microsoft.DotNet.PackageTesting`
`16`	`17`	`{`
`17`	`18`	`/// <summary>`
`18`	`19`	`/// Verifies the closure of a set of DLLs, making sure all files are present and no cycles exist`
`@@ -125,7 +126,7 @@ private void AddSourceFile(string file)`
`125`	`126`
`126`	`127`	`private void LoadIgnoredReferences()`
`127`	`128`	`{`
`128`		`- foreach (var ignoredReference in IgnoredReferences.NullAsEmpty())`
	`129`	`+ foreach (var ignoredReference in IgnoredReferences.DefaultIfEmpty())`
`129`	`130`	`{`
`130`	`131`	`var name = ignoredReference.ItemSpec;`
`131`	`132`	`var versionString = ignoredReference.GetMetadata("Version");`
`@@ -175,7 +176,7 @@ void CheckDependencies(Stack<AssemblyInfo> depStack)`
`175`	`176`	`// check module references`
`176`	`177`	`if (assm.State == CheckState.Unchecked && CheckModuleReferences)`
`177`	`178`	`{`
`178`		`- foreach(var moduleReference in assm.ModuleReferences.NullAsEmpty())`
	`179`	`+ foreach(var moduleReference in assm.ModuleReferences.DefaultIfEmpty())`
`179`	`180`	`{`
`180`	`181`	`if (ShouldIgnore(moduleReference))`
`181`	`182`	`{`