dependabot-nuget 0.240.0 → 0.242.0

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Utilities/XmlExtensions.cs

@@ -0,0 +1,124 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+using Microsoft.Language.Xml;
+
+namespace NuGetUpdater.Core;
+
+public static class XmlExtensions
+{
+    public static string? GetAttributeOrSubElementValue(this IXmlElementSyntax element, string name, StringComparison comparisonType = StringComparison.Ordinal)
+    {
+        var attribute = element.GetAttribute(name, comparisonType);
+        if (attribute is not null)
+        {
+            return attribute.Value;
+        }
+
+        var subElement = element.GetElements(name, comparisonType).FirstOrDefault();
+        return subElement?.GetContentValue();
+    }
+
+    public static IEnumerable<IXmlElementSyntax> GetElements(this IXmlElementSyntax element, string name, StringComparison comparisonType = StringComparison.Ordinal)
+    {
+        return element.Elements.Where(a => a.Name.Equals(name, comparisonType));
+    }
+
+    public static XmlAttributeSyntax? GetAttribute(this IXmlElementSyntax element, string name, StringComparison comparisonType)
+    {
+        return element.Attributes.FirstOrDefault(a => a.Name.Equals(name, comparisonType));
+    }
+
+    public static string GetAttributeValue(this IXmlElementSyntax element, string name, StringComparison comparisonType)
+    {
+        return element.Attributes.First(a => a.Name.Equals(name, comparisonType)).Value;
+    }
+
+    public static XmlAttributeSyntax? GetAttributeCaseInsensitive(this IXmlElementSyntax xml, string name) => GetAttribute(xml, name, StringComparison.OrdinalIgnoreCase);
+
+    public static string? GetAttributeValueCaseInsensitive(this IXmlElementSyntax xml, string name) => xml.GetAttributeCaseInsensitive(name)?.Value;
+
+    public static IXmlElementSyntax WithChildElement(this IXmlElementSyntax parent, string name)
+    {
+        var element = CreateOpenCloseXmlElementSyntax(name);
+        return parent.AddChild(element);
+    }
+
+    public static IXmlElementSyntax WithEmptyChildElement(this IXmlElementSyntax parent, string name)
+    {
+        var element = CreateSingleLineXmlElementSyntax(name);
+        return parent.AddChild(element);
+    }
+
+    public static IXmlElementSyntax WithContent(this IXmlElementSyntax element, string text)
+    {
+        var textSyntax = SyntaxFactory.XmlText(SyntaxFactory.Token(null, SyntaxKind.XmlTextLiteralToken, null, text));
+        return element.WithContent(SyntaxFactory.SingletonList(textSyntax));
+    }
+
+    public static IXmlElementSyntax WithAttribute(this IXmlElementSyntax parent, string name, string value)
+    {
+        var singleSpanceTrivia = SyntaxFactory.WhitespaceTrivia(" ");
+
+        return parent.AddAttribute(SyntaxFactory.XmlAttribute(
+            SyntaxFactory.XmlName(null, SyntaxFactory.XmlNameToken(name, null, null)),
+            SyntaxFactory.Punctuation(SyntaxKind.EqualsToken, "=", null, null),
+            SyntaxFactory.XmlString(
+                SyntaxFactory.Punctuation(SyntaxKind.SingleQuoteToken, "\"", null, null),
+                SyntaxFactory.XmlTextLiteralToken(value, null, null),
+                SyntaxFactory.Punctuation(SyntaxKind.SingleQuoteToken, "\"", null, singleSpanceTrivia))));
+    }
+
+    public static XmlElementSyntax CreateOpenCloseXmlElementSyntax(string name, int indentation = 2, bool spaces = true)
+    {
+        var leadingTrivia = SyntaxFactory.WhitespaceTrivia(new string(' ', indentation));
+        return CreateOpenCloseXmlElementSyntax(name, new SyntaxList<SyntaxNode>(leadingTrivia));
+    }
+
+    public static XmlElementSyntax CreateOpenCloseXmlElementSyntax(string name, SyntaxList<SyntaxNode> leadingTrivia)
+    {
+        var newlineTrivia = SyntaxFactory.WhitespaceTrivia(Environment.NewLine);
+
+        return SyntaxFactory.XmlElement(
+            SyntaxFactory.XmlElementStartTag(
+                SyntaxFactory.Punctuation(SyntaxKind.LessThanToken, "<", leadingTrivia, default),
+                SyntaxFactory.XmlName(null, SyntaxFactory.XmlNameToken(name, null, null)),
+                new SyntaxList<XmlAttributeSyntax>(),
+                SyntaxFactory.Punctuation(SyntaxKind.GreaterThanToken, ">", null, newlineTrivia)),
+            new SyntaxList<SyntaxNode>(),
+            SyntaxFactory.XmlElementEndTag(
+                SyntaxFactory.Punctuation(SyntaxKind.LessThanSlashToken, "</", leadingTrivia, default),
+                SyntaxFactory.XmlName(null, SyntaxFactory.XmlNameToken(name, null, null)),
+                SyntaxFactory.Punctuation(SyntaxKind.GreaterThanToken, ">", null, null)));
+    }
+
+    public static XmlEmptyElementSyntax CreateSingleLineXmlElementSyntax(string name, int indentation = 2, bool spaces = true)
+    {
+        var leadingTrivia = SyntaxFactory.WhitespaceTrivia(new string(' ', indentation));
+        var followingTrivia = SyntaxFactory.WhitespaceTrivia(Environment.NewLine);
+
+        return CreateSingleLineXmlElementSyntax(name, new SyntaxList<SyntaxNode>(leadingTrivia), new SyntaxList<SyntaxNode>(followingTrivia));
+    }
+
+    public static XmlEmptyElementSyntax CreateSingleLineXmlElementSyntax(string name, SyntaxList<SyntaxNode> leadingTrivia, SyntaxList<SyntaxNode> trailingTrivia = default)
+    {
+        var singleSpanceTrivia = SyntaxFactory.WhitespaceTrivia(" ");
+
+        return SyntaxFactory.XmlEmptyElement(
+            SyntaxFactory.Punctuation(SyntaxKind.LessThanToken, "<", leadingTrivia, default),
+            SyntaxFactory.XmlName(null, SyntaxFactory.XmlNameToken(name, null, singleSpanceTrivia)),
+            attributes: new SyntaxList<SyntaxNode>(),
+            SyntaxFactory.Punctuation(SyntaxKind.SlashGreaterThanToken, "/>", default, trailingTrivia));
+    }
+
+    public static IXmlElementSyntax ReplaceAttribute(this IXmlElementSyntax element, XmlAttributeSyntax oldAttribute, XmlAttributeSyntax newAttribute)
+    {
+        return element.WithAttributes(element.AttributesNode.Replace(oldAttribute, newAttribute));
+    }
+
+    public static IXmlElementSyntax ReplaceChildElement(this IXmlElementSyntax element, IXmlElementSyntax oldChildElement, IXmlElementSyntax newChildElement)
+    {
+        return element.WithContent(element.Content.Replace(oldChildElement.AsNode, newChildElement.AsNode));
+    }
+}

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/Files/DotNetToolsJsonBuildFileTests.cs

@@ -0,0 +1,53 @@
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+
+using Xunit;
+
+namespace NuGetUpdater.Core.Test.Files;
+
+public class DotnetToolsJsonBuildFileTests
+{
+    [StringSyntax(StringSyntaxAttribute.Json)]
+    const string DotnetToolsJson = """
+        {
+          "version": 1,
+          "isRoot": true,
+          "tools": {
+            "microsoft.botsay": {
+              "version": "1.0.0",
+              "commands": [
+                "botsay"
+              ]
+            },
+            "dotnetsay": {
+              "version": "2.1.3",
+              "commands": [
+                "dotnetsay"
+              ]
+            }
+          }
+        }
+        """;
+
+    private static DotNetToolsJsonBuildFile GetBuildFile() => new(
+        repoRootPath: "/",
+        path: "/.config/dotnet-tools.json",
+        contents: DotnetToolsJson,
+        logger: new Logger(verbose: true));
+
+    [Fact]
+    public void GetDependencies_ReturnsDependencies()
+    {
+        var expectedDependencies = new List<Dependency>
+        {
+            new("microsoft.botsay", "1.0.0", DependencyType.DotNetTool),
+            new("dotnetsay", "2.1.3", DependencyType.DotNetTool)
+        };
+
+        var buildFile = GetBuildFile();
+
+        var dependencies = buildFile.GetDependencies();
+
+        Assert.Equal(expectedDependencies, dependencies);
+    }
+}

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/Files/GlobalJsonBuildFileTests.cs

@@ -0,0 +1,80 @@
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+
+using Xunit;
+
+namespace NuGetUpdater.Core.Test.Files;
+
+public class GlobalJsonBuildFileTests
+{
+    [StringSyntax(StringSyntaxAttribute.Json)]
+    const string GlobalJson = """
+        {
+          "sdk": {
+            "version": "6.0.405",
+            "rollForward": "latestPatch"
+          },
+          "msbuild-sdks": {
+            "My.Custom.Sdk": "5.0.0",
+            "My.Other.Sdk": "1.0.0-beta"
+          }
+        }
+        """;
+
+    [StringSyntax(StringSyntaxAttribute.Json)]
+    const string EmptyGlobalJson = """
+        {
+        }
+        """;
+
+    private static GlobalJsonBuildFile GetBuildFile(string contents) => new(
+        repoRootPath: "/",
+        path: "/global.json",
+        contents: contents,
+        logger: new Logger(verbose: true));
+
+    [Fact]
+    public void GlobalJson_Malformed_DoesNotThrow()
+    {
+        var buildFile = GetBuildFile("""[{ "Random": "stuff"}]""");
+
+        Assert.Null(buildFile.MSBuildSdks);
+    }
+
+    [Fact]
+    public void GlobalJson_NotJson_DoesNotThrow()
+    {
+        var buildFile = GetBuildFile("not json");
+
+        Assert.Null(buildFile.MSBuildSdks);
+    }
+
+    [Fact]
+    public void GlobalJson_GetDependencies_ReturnsDependencies()
+    {
+        var expectedDependencies = new List<Dependency>
+        {
+            new("My.Custom.Sdk", "5.0.0", DependencyType.MSBuildSdk),
+            new("My.Other.Sdk", "1.0.0-beta", DependencyType.MSBuildSdk)
+        };
+
+        var buildFile = GetBuildFile(GlobalJson);
+
+        var dependencies = buildFile.GetDependencies();
+
+        Assert.Equal(expectedDependencies, dependencies);
+    }
+
+    [Fact]
+    public void EmptyGlobalJson_GetDependencies_ReturnsNoDependencies()
+    {
+        var expectedDependencies = Enumerable.Empty<Dependency>();
+
+        var buildFile = GetBuildFile(EmptyGlobalJson);
+
+        var dependencies = buildFile.GetDependencies();
+
+        Assert.Equal(expectedDependencies, dependencies);
+    }
+}

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/Files/PackagesConfigBuildFileTests.cs

@@ -0,0 +1,63 @@
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+
+using Microsoft.Language.Xml;
+
+using Xunit;
+
+namespace NuGetUpdater.Core.Test.Files;
+
+public class PackagesConfigBuildFileTests
+{
+    [StringSyntax(StringSyntaxAttribute.Xml)]
+    const string PackagesConfig = """
+        <?xml version="1.0" encoding="utf-8"?>
+        <packages>
+          <package id="Microsoft.CodeDom.Providers.DotNetCompilerPlatform" version="1.0.0" targetFramework="net46" />
+          <package id="Microsoft.Net.Compilers" version="1.0.0" targetFramework="net46" developmentDependency="true" />
+          <package id="Newtonsoft.Json" version="8.0.3" allowedVersions="[8,10)" targetFramework="net46" />
+        </packages>
+        """;
+
+    [StringSyntax(StringSyntaxAttribute.Xml)]
+    const string EmptyPackagesConfig = """
+        <?xml version="1.0" encoding="utf-8"?>
+        <packages>
+        </packages>
+        """;
+
+    private static PackagesConfigBuildFile GetBuildFile(string contents) => new(
+        repoRootPath: "/",
+        path: "/packages.config",
+        contents: Parser.ParseText(contents));
+
+    [Fact]
+    public void PackagesConfig_GetDependencies_ReturnsDependencies()
+    {
+        var expectedDependencies = new List<Dependency>
+        {
+            new("Microsoft.CodeDom.Providers.DotNetCompilerPlatform", "1.0.0", DependencyType.PackageConfig),
+            new("Microsoft.Net.Compilers", "1.0.0", DependencyType.PackageConfig, true),
+            new("Newtonsoft.Json", "8.0.3", DependencyType.PackageConfig)
+        };
+
+        var buildFile = GetBuildFile(PackagesConfig);
+
+        var dependencies = buildFile.GetDependencies();
+
+        Assert.Equal(expectedDependencies, dependencies);
+    }
+
+    [Fact]
+    public void EmptyPackagesConfig_GetDependencies_ReturnsNoDependencies()
+    {
+        var expectedDependencies = Enumerable.Empty<Dependency>();
+
+        var buildFile = GetBuildFile(EmptyPackagesConfig);
+
+        var dependencies = buildFile.GetDependencies();
+
+        Assert.Equal(expectedDependencies, dependencies);
+    }
+}

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/Files/ProjectBuildFileTests.cs

@@ -0,0 +1,154 @@
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using System.Text.RegularExpressions;
+
+using Microsoft.Language.Xml;
+
+using Xunit;
+
+namespace NuGetUpdater.Core.Test.Files;
+
+public class ProjectBuildFileTests
+{
+    [StringSyntax(StringSyntaxAttribute.Xml)]
+    const string ProjectCsProj = """
+        <Project Sdk="Microsoft.NET.Sdk">
+          <PropertyGroup>
+            <OutputType>Exe</OutputType>
+            <TargetFramework>net7.0</TargetFramework>
+          </PropertyGroup>
+          <ItemGroup>
+            <ProjectReference Include=".\Library\Library.csproj" />
+          </ItemGroup>
+          <ItemGroup>
+            <PackageReference Include="GuiLabs.Language.Xml" Version="1.2.60" />
+            <PackageReference Include="Microsoft.CodeAnalysis.CSharp" />
+            <PackageReference Update="Newtonsoft.Json" VersionOverride="13.0.3" />
+          </ItemGroup>
+        </Project>
+        """;
+
+    [StringSyntax(StringSyntaxAttribute.Xml)]
+    const string EmptyProject = """
+        <Project>
+        </Project>
+        """;
+
+    [StringSyntax(StringSyntaxAttribute.Xml)]
+    const string DirectoryPackagesProps = """
+        <Project>
+          <PropertyGroup>
+            <ManagePackageVersionsCentrally>true</ManagePackageVersionsCentrally>
+            <CentralPackageTransitivePinningEnabled>true</CentralPackageTransitivePinningEnabled>
+          </PropertyGroup>
+          <ItemGroup>
+            <GlobalPackageReference Include="Microsoft.CodeAnalysis.Common" Version="$(RoslynVersion)" />
+            <PackageVersion Include="Newtonsoft.Json" VersionOverride="13.0.1" />
+          </ItemGroup>
+        </Project>
+        """;
+
+    private static ProjectBuildFile GetBuildFile(string contents, string filename) => new(
+        repoRootPath: "/",
+        path: $"/{filename}",
+        contents: Parser.ParseText(contents));
+
+    [Fact]
+    public void ProjectCsProj_GetDependencies_ReturnsDependencies()
+    {
+        var expectedDependencies = new List<Dependency>
+        {
+            new("GuiLabs.Language.Xml", "1.2.60", DependencyType.PackageReference),
+            new("Microsoft.CodeAnalysis.CSharp", null, DependencyType.PackageReference),
+            new("Newtonsoft.Json", "13.0.3", DependencyType.PackageReference, IsOverride: true)
+        };
+
+        var buildFile = GetBuildFile(ProjectCsProj, "Project.csproj");
+
+        var dependencies = buildFile.GetDependencies();
+
+        Assert.Equal(expectedDependencies, dependencies);
+    }
+
+    [Fact]
+    public void ProjectCsProj_ReferencedProjectPaths_ReturnsPaths()
+    {
+        var expectedReferencedProjectPaths = new List<string>
+        {
+            "/Library/Library.csproj"
+        };
+
+        var buildFile = GetBuildFile(ProjectCsProj, "Project.csproj");
+
+        var referencedProjectPaths = buildFile.GetReferencedProjectPaths()
+            .Select(p => Regex.IsMatch(p, @"^[A-Z]:\\") ? "/" + p.Substring(@"C:\".Length) : p) // remove drive letter when testing on Windows
+            .Select(p => p.NormalizePathToUnix());
+
+        Assert.Equal(expectedReferencedProjectPaths, referencedProjectPaths);
+    }
+
+    [Fact]
+    public void DirectoryPackagesProps_GetDependencies_ReturnsDependencies()
+    {
+        var expectedDependencies = new List<Dependency>
+        {
+            new("Microsoft.CodeAnalysis.Common", "$(RoslynVersion)", DependencyType.GlobalPackageReference),
+            new("Newtonsoft.Json", "13.0.1", DependencyType.PackageVersion, IsOverride: true)
+        };
+
+        var buildFile = GetBuildFile(DirectoryPackagesProps, "Directory.Packages.props");
+
+        var dependencies = buildFile.GetDependencies();
+
+        Assert.Equal(expectedDependencies, dependencies);
+    }
+
+    [Fact]
+    public void DirectoryPackagesProps_Properties_ReturnsProperties()
+    {
+        var expectedProperties = new List<KeyValuePair<string, string>>
+        {
+            new("ManagePackageVersionsCentrally", "true"),
+            new("CentralPackageTransitivePinningEnabled", "true")
+        };
+
+        var buildFile = GetBuildFile(DirectoryPackagesProps, "Directory.Packages.props");
+
+        var properties = buildFile.GetProperties();
+
+        Assert.Equal(expectedProperties, properties);
+    }
+
+    [Fact]
+    public void EmptyProject_GetDependencies_ReturnsNoDependencies()
+    {
+        var expectedDependencies = Enumerable.Empty<Dependency>();
+
+        var buildFile = GetBuildFile(EmptyProject, "project.csproj");
+
+        var dependencies = buildFile.GetDependencies();
+
+        Assert.Equal(expectedDependencies, dependencies);
+    }
+
+    [Theory]
+    [InlineData( // no change made
+    @"<Project><ItemGroup><Reference><HintPath>path\to\file.dll</HintPath></Reference></ItemGroup></Project>",
+    @"<Project><ItemGroup><Reference><HintPath>path\to\file.dll</HintPath></Reference></ItemGroup></Project>"
+    )]
+    [InlineData( // change from `/` to `\`
+    "<Project><ItemGroup><Reference><HintPath>path/to/file.dll</HintPath></Reference></ItemGroup></Project>",
+    @"<Project><ItemGroup><Reference><HintPath>path\to\file.dll</HintPath></Reference></ItemGroup></Project>"
+    )]
+    [InlineData( // multiple changes made
+    "<Project><ItemGroup><Reference><HintPath>path1/to1/file1.dll</HintPath></Reference><Reference><HintPath>path2/to2/file2.dll</HintPath></Reference></ItemGroup></Project>",
+    @"<Project><ItemGroup><Reference><HintPath>path1\to1\file1.dll</HintPath></Reference><Reference><HintPath>path2\to2\file2.dll</HintPath></Reference></ItemGroup></Project>"
+    )]
+    public void ReferenceHintPathsCanBeNormalized(string originalXml, string expectedXml)
+    {
+        ProjectBuildFile? buildFile = GetBuildFile(originalXml, "project.csproj");
+        buildFile.NormalizeDirectorySeparatorsInProject();
+        Assert.Equal(expectedXml, buildFile.Contents.ToFullString());
+    }
+}

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/FrameworkChecker/CompatibilityCheckerFacts.cs

@@ -0,0 +1,64 @@
+using NuGetUpdater.Core.FrameworkChecker;
+
+using Xunit;
+
+namespace NuGetUpdater.Core.Test.FrameworkChecker;
+
+public class CompatibilityCheckerFacts
+{
+    [Theory]
+    [InlineData("net8.0", "net8.0")]
+    [InlineData("net8.0", "net7.0")]
+    [InlineData("net7.0", "net7.0")]
+    [InlineData("net7.0", "net6.0")]
+    [InlineData("net7.0", "net5.0")]
+    [InlineData("net7.0", "netcoreapp3.1")]
+    [InlineData("net7.0", "netstandard2.1")]
+    [InlineData("net7.0", "netstandard2.0")]
+    [InlineData("net7.0", "netstandard1.3")]
+    [InlineData("net4.8", "netstandard2.0")]
+    [InlineData("net4.8", "netstandard1.3")]
+    public void PackageContainsCompatibleFramework(string projectTfm, string packageTfm)
+    {
+        var result = CompatibilityChecker.IsCompatible(new[] { projectTfm }, new[] { packageTfm }, new Logger(verbose: true));
+
+        Assert.True(result);
+    }
+
+    [Theory]
+    [InlineData("net48", "netcoreapp3.1")]
+    [InlineData("net48", "netstandard2.1")]
+    [InlineData("net7.0", "net8.0")]
+    [InlineData("net6.0", "net7.0")]
+    [InlineData("net5.0", "net6.0")]
+    [InlineData("netcoreapp3.1", "net5.0")]
+    [InlineData("netstandard2.0", "netstandard2.1")]
+    [InlineData("netstandard1.3", "netstandard2.0")]
+    [InlineData("net7.0", "net48")]
+    public void PackageContainsIncompatibleFramework(string projectTfm, string packageTfm)
+    {
+        var result = CompatibilityChecker.IsCompatible(new[] { projectTfm }, new[] { packageTfm }, new Logger(verbose: true));
+
+        Assert.False(result);
+    }
+
+    [Theory]
+    [InlineData(new[] { "net8.0", "net7.0", "net472" }, new[] { "netstandard2.0" })]
+    [InlineData(new[] { "net8.0", "net7.0", "net472" }, new[] { "net5.0", "net461" })]
+    [InlineData(new[] { "net6.0", "net6.0-windows10.0.19041" }, new[] { "net6.0", ".NETStandard2.0" })]
+    public void PackageContainsCompatibleFrameworks(string[] projectTfms, string[] packageTfms)
+    {
+        var result = CompatibilityChecker.IsCompatible(projectTfms, packageTfms, new Logger(verbose: true));
+
+        Assert.True(result);
+    }
+
+    [Theory]
+    [InlineData(new[] { "net7.0", "net472" }, new[] { "net5.0" })]
+    public void PackageContainsIncompatibleFrameworks(string[] projectTfms, string[] packageTfms)
+    {
+        var result = CompatibilityChecker.IsCompatible(projectTfms, packageTfms, new Logger(verbose: true));
+
+        Assert.False(result);
+    }
+}

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core.Test/FrameworkChecker/FrameworkCompatibilityServiceFacts.cs

@@ -0,0 +1,122 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+using NuGet.Frameworks;
+
+using NuGetUpdater.Core.FrameworkChecker;
+
+using Xunit;
+
+namespace NuGetUpdater.Core.Test.FrameworkChecker;
+
+public class FrameworkCompatibilityServiceFacts
+{
+    private readonly FrameworkCompatibilityService _service;
+    private readonly IFrameworkCompatibilityProvider _compatibilityProvider = DefaultCompatibilityProvider.Instance;
+
+    public FrameworkCompatibilityServiceFacts()
+    {
+        _service = new FrameworkCompatibilityService();
+    }
+
+    [Fact]
+    public void NullPackageFrameworksThrowsArgumentNullException()
+    {
+        Assert.Throws<ArgumentNullException>(() => _service.GetCompatibleFrameworks(null));
+    }
+
+    [Fact]
+    public void EmptyPackageFrameworksReturnsEmptySet()
+    {
+        var result = _service.GetCompatibleFrameworks(new List<NuGetFramework>());
+
+        Assert.Empty(result);
+    }
+
+    [Fact]
+    public void UnknownSupportedPackageReturnsSetWithSameFramework()
+    {
+        var framework = NuGetFramework.Parse("net45-client");
+        var frameworks = new List<NuGetFramework>() { framework };
+        var compatible = _service.GetCompatibleFrameworks(frameworks);
+
+        Assert.False(framework.IsUnsupported);
+        Assert.Equal(expected: 1, compatible.Count);
+        Assert.Contains(framework, compatible);
+    }
+
+    [Theory]
+    [InlineData("1000")]
+    [InlineData("lib")]
+    [InlineData("nuget")]
+    public void UnsupportedPackageFrameworksReturnsEmptySet(string unsupportedFrameworkName)
+    {
+        var unsupportedFramework = NuGetFramework.Parse(unsupportedFrameworkName);
+
+        var result = _service.GetCompatibleFrameworks(new List<NuGetFramework>() { unsupportedFramework });
+
+        Assert.True(unsupportedFramework.IsUnsupported);
+        Assert.Equal(expected: 0, actual: result.Count);
+    }
+
+    [Theory]
+    [InlineData("portable-net45+sl4+win8+wp7")]
+    [InlineData("portable-net40+sl4")]
+    [InlineData("portable-net45+sl5+win8+wpa81+wp8")]
+    public void PCLPackageFrameworksReturnsEmptySet(string pclFrameworkName)
+    {
+        var portableFramework = NuGetFramework.Parse(pclFrameworkName);
+
+        var result = _service.GetCompatibleFrameworks(new List<NuGetFramework>() { portableFramework });
+
+        Assert.True(portableFramework.IsPCL);
+        Assert.Equal(expected: 0, actual: result.Count);
+    }
+
+    [Theory]
+    [InlineData("net5.0", "netcoreapp2.0", "win81")]
+    [InlineData("sl4", "netstandard1.2", "netmf")]
+    public void ValidPackageFrameworksReturnsFrameworksCompatibleForAtLeastOne(params string[] frameworkNames)
+    {
+        var frameworks = new List<NuGetFramework>();
+
+        foreach (var frameworkName in frameworkNames)
+        {
+            frameworks.Add(NuGetFramework.Parse(frameworkName));
+        }
+
+        var compatibleFrameworks = _service.GetCompatibleFrameworks(frameworks);
+
+        Assert.True(compatibleFrameworks.Count > 0);
+
+        foreach (var compatibleFramework in compatibleFrameworks)
+        {
+            var isCompatible = frameworks.Any(f => _compatibilityProvider.IsCompatible(compatibleFramework, f));
+
+            Assert.True(isCompatible);
+        }
+    }
+
+    [Theory]
+    [InlineData("net6.0-windows7.0", "net6.0-windows", "net6.0-windows7.0", "net7.0-windows", "net7.0-windows7.0")]
+    public void WindowsPlatformVersionsShouldContainAllSpecifiedFrameworks(string windowsDefaultVersionFramework, params string[] windowsProjectFrameworks)
+    {
+        var packageFramework = NuGetFramework.Parse(windowsDefaultVersionFramework);
+        var projectFrameworks = new HashSet<NuGetFramework>();
+
+        foreach (var frameworkName in windowsProjectFrameworks)
+        {
+            projectFrameworks.Add(NuGetFramework.Parse(frameworkName));
+        }
+
+        var compatibleFrameworks = _service.GetCompatibleFrameworks(new HashSet<NuGetFramework>() { packageFramework });
+        Assert.Equal(windowsProjectFrameworks.Length, compatibleFrameworks.Count);
+
+        var containsAllCompatibleFrameworks = compatibleFrameworks.All(cf => projectFrameworks.Contains(cf));
+        Assert.True(containsAllCompatibleFrameworks);
+    }
+}