From 78b3f51220606d80aa7fd692ab06b34d472f5951 Mon Sep 17 00:00:00 2001
From: Eric Erhardt <eric.erhardt@microsoft.com>
Date: Tue, 31 Mar 2020 16:05:38 -0500
Subject: [PATCH] Remove references to PlatformAbstractions.

This will allow us to remove the PlatformAbstractions library from dotnet/runtime.

Contributes to https://github.com/dotnet/runtime/issues/3470
---
 eng/Version.Details.xml                       |   6 +-
 eng/Versions.props                            |   4 +-
 .../Microsoft.DotNet.Cli.Utils/Constants.cs   |   6 +-
 .../DangerousFileDetector.cs                  |   4 +-
 .../Microsoft.DotNet.Cli.Utils/DotnetFiles.cs |   1 -
 .../EnvironmentProvider.cs                    |   6 +-
 .../FileNameSuffixes.cs                       |  31 +-
 .../FrameworkDependencyFile.cs                |  12 +-
 .../Microsoft.DotNet.Cli.Utils.csproj         |   1 -
 .../Microsoft.DotNet.Cli.Utils/PathUtility.cs |   8 +-
 .../ProcessReaper.cs                          |  13 +-
 .../RuntimeEnvironment.cs                     | 372 ++++++++++++++++++
 .../RuntimeEnvironmentRidExtensions.cs        |  33 --
 .../AppBaseCommandResolver.cs                 |   4 +-
 .../AppBaseDllCommandResolver.cs              |   4 +-
 .../DefaultCommandResolverPolicy.cs           |   4 +-
 .../DotnetToolsCommandResolver.cs             |   6 +-
 .../LocalToolsCommandResolver.cs              |   7 +-
 .../PathCommandResolverPolicy.cs              |   4 +-
 .../ScriptCommandResolverPolicy.cs            |   4 +-
 .../MulticoreJitProfilePathCalculator.cs      |   3 +-
 src/Cli/dotnet/Program.cs                     |  10 +-
 src/Cli/dotnet/ShellShim/AppHostShimMaker.cs  |   4 +-
 .../dotnet/ShellShim/ShellShimRepository.cs   |   2 -
 .../DockerContainerDetectorForTelemetry.cs    |  50 +--
 .../Telemetry/ExternalTelemetryProperties.cs  |  14 +-
 src/Cli/dotnet/Telemetry/Telemetry.cs         |   3 -
 .../Telemetry/TelemetryCommonProperties.cs    |  12 +-
 .../dotnet-tool/install/ProjectRestorer.cs    |   2 -
 src/Cli/dotnet/dotnet.csproj                  |   1 -
 .../targets/GetRuntimeInformation.targets     |   3 -
 src/Layout/toolset-tasks/CurrentPlatform.cs   |  50 +--
 .../GetCurrentRuntimeInformation.cs           |   6 +-
 src/Layout/toolset-tasks/toolset-tasks.csproj |   8 +-
 .../FrameworkReferenceResolver.cs             |   5 +-
 .../Microsoft.NET.Build.Tasks.csproj          |   2 -
 .../ArgumentForwarding.Tests.csproj           |   4 -
 .../EndToEnd.Tests/EndToEnd.Tests.csproj      |   4 -
 .../GivenAProjectPathCommandResolver.cs       |   2 -
 .../GivenAnAppBaseCommandResolver.cs          |   2 -
 .../Microsoft.NET.Build.Tests/AppHostTests.cs |   9 +-
 ...GivenThatWeWantToBuildAComServerLibrary.cs |   5 +-
 ...WantToBuildASolutionWithProjRefDiffCase.cs |   8 +-
 ...atWeWantToBuildAnAppWithLibrariesAndRid.cs |   6 +-
 .../GivenThatWeWantToCopyLocalDependencies.cs |   1 -
 ...enThatWeWantToFilterSatelliteAssemblies.cs |   9 +-
 .../GivenThatWeWantToUseVB.cs                 |   1 -
 ...venWeWantToRequireWindowsForDesktopApps.cs |   7 +-
 ...enThatWeWantToPackACrossTargetedLibrary.cs |   3 -
 .../GivenThatWeWantToPackASimpleLibrary.cs    |   3 -
 .../FilesCopiedToPublishDirTests.cs           |   9 +-
 ...nThatWeWantToExcludeAPackageFromPublish.cs |   9 +-
 ...enThatWeWantToFilterSatelliteAssemblies.cs |   7 +-
 ...atWeWantToPublishAFrameworkDependentApp.cs |   7 +-
 ...enThatWeWantToPublishAHelloWorldProject.cs |   4 -
 ...WeWantToPublishAProjectWithDependencies.cs |   2 +-
 ...venThatWeWantToPublishASelfContainedApp.cs |   6 +-
 .../GivenThatWeWantToPublishASingleFileApp.cs |   6 +-
 .../GivenThatWeWantToPublishAWebApp.cs        |   1 -
 ...WeWantToPublishAnAppWithLibrariesAndRid.cs |   9 +-
 ...atWeWantToPublishAnUnpublishableProject.cs |   7 +-
 .../GivenThatWeWantToPublishReadyToRun.cs     |   2 +-
 .../GivenThatWeWantToRunILLink.cs             |   4 +-
 ...atWeWantToStoreAProjectWithDependencies.cs |   2 +-
 .../PublishItemsOutputGroupTests.cs           |   9 +-
 .../PublishWebApp.cs                          |  14 +-
 .../PublishWpfApp.cs                          |  19 +-
 .../AssertionHelper.cs                        |   4 +-
 .../CoreMSBuildAndWindowsOnlyFactAttribute.cs |   5 +-
 ...oreMSBuildAndWindowsOnlyTheoryAttribute.cs |   5 +-
 .../CoreMSBuildOnlyFactAttribute.cs           |   2 -
 .../CoreMSBuildOnlyTheoryAttribute.cs         |   1 -
 .../Attributes/PlatformSpecificFact.cs        |  13 +-
 .../Attributes/PlatformSpecificTheory.cs      |   6 +-
 .../Attributes/UnixOnlyFactAttribute.cs       |   4 +-
 .../Attributes/UnixOnlyTheoryAttribute.cs     |  10 +-
 .../Attributes/WindowsOnlyFactAttribute.cs    |   4 +-
 .../Attributes/WindowsOnlyTheoryAttribute.cs  |   4 +-
 .../Commands/ComposeStoreCommand.cs           |   4 -
 .../Commands/PublishCommand.cs                |   5 -
 .../Commands/SdkCommandSpec.cs                |   9 +-
 .../EnvironmentInfo.cs                        |   9 +-
 .../LinuxOnlyFactAttribute.cs                 |   4 +-
 .../MacOsOnlyFactAttribute.cs                 |   4 +-
 .../Microsoft.NET.TestFramework.csproj        |   1 +
 .../GivenThatWeWantToPackAToolProject.cs      |   4 +-
 .../GivenDotnetPublishPublishesProjects.cs    |  10 +-
 .../GivenDotnetRunRunsCsProj.cs               |   3 +-
 .../GivenDotnetStoresAndPublishesProjects.cs  |   5 +-
 .../GivenThatIWantToManageMulticoreJIT.cs     |   5 +-
 .../TelemetryCommonPropertiesTests.cs         |   4 +-
 src/Tests/dotnet.Tests/dotnet.Tests.csproj    |   1 -
 toolset/eng/Versions.props                    |   2 -
 .../binding-redirects.Tests.csproj            |   4 -
 94 files changed, 595 insertions(+), 423 deletions(-)
 create mode 100644 src/Cli/Microsoft.DotNet.Cli.Utils/RuntimeEnvironment.cs
 delete mode 100644 src/Cli/Microsoft.DotNet.Cli.Utils/RuntimeEnvironmentRidExtensions.cs

diff --git a/eng/Version.Details.xml b/eng/Version.Details.xml
index 9c2c9ca9df02..e7ad995c1cdd 100644
--- a/eng/Version.Details.xml
+++ b/eng/Version.Details.xml
@@ -13,9 +13,9 @@
       <Uri>https://github.com/dotnet/runtime</Uri>
       <Sha>6e83eafe49ce3c55e9f68ae669f24957e5b482f8</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.DotNet.PlatformAbstractions" Version="5.0.0-preview.4.20213.12">
-      <Uri>https://github.com/dotnet/runtime</Uri>
-      <Sha>6e83eafe49ce3c55e9f68ae669f24957e5b482f8</Sha>
+    <Dependency Name="Microsoft.DotNet.XUnitExtensions" Version="5.0.0-beta.20201.2">
+      <Uri>https://github.com/dotnet/arcade</Uri>
+      <Sha>bce0a98620c1c5a110b2bba9912f3d5929069c6b</Sha>
     </Dependency>
     <Dependency Name="Microsoft.NET.HostModel" Version="5.0.0-preview.4.20213.12">
       <Uri>https://github.com/dotnet/runtime</Uri>
diff --git a/eng/Versions.props b/eng/Versions.props
index 57c0babd8715..2e5ec8d5693a 100644
--- a/eng/Versions.props
+++ b/eng/Versions.props
@@ -18,7 +18,6 @@
     <MicrosoftExtensionsDependencyModelVersion>2.1.0-preview2-26306-03</MicrosoftExtensionsDependencyModelVersion>
     <MicrosoftApplicationInsightsPackageVersion>2.0.0</MicrosoftApplicationInsightsPackageVersion>
     <NETStandardLibraryNETFrameworkVersion>2.0.1-servicing-26011-01</NETStandardLibraryNETFrameworkVersion>
-    <PlatformAbstractionsVersion>2.0.0</PlatformAbstractionsVersion>
     <NewtonsoftJsonPackageVersion>11.0.1</NewtonsoftJsonPackageVersion>
     <NewtonsoftJsonVersion>$(NewtonsoftJsonPackageVersion)</NewtonsoftJsonVersion>
     <SystemDiagnosticsFileVersionInfoVersion>4.0.0</SystemDiagnosticsFileVersionInfoVersion>
@@ -30,11 +29,9 @@
     <MicrosoftNETCoreAppRefPackageVersion>5.0.0-preview.4.20213.12</MicrosoftNETCoreAppRefPackageVersion>
     <MicrosoftNETCoreAppRuntimewinx64PackageVersion>5.0.0-preview.4.20213.12</MicrosoftNETCoreAppRuntimewinx64PackageVersion>
     <MicrosoftNETCoreAppRuntimePackageVersion>$(MicrosoftNETCoreAppRuntimewinx64PackageVersion)</MicrosoftNETCoreAppRuntimePackageVersion>
-    <MicrosoftDotNetPlatformAbstractionsPackageVersion>5.0.0-preview.4.20213.12</MicrosoftDotNetPlatformAbstractionsPackageVersion>
     <MicrosoftExtensionsDependencyModelPackageVersion>5.0.0-preview.4.20202.18</MicrosoftExtensionsDependencyModelPackageVersion>
     <MicrosoftNETCoreDotNetHostResolverPackageVersion>5.0.0-preview.4.20213.12</MicrosoftNETCoreDotNetHostResolverPackageVersion>
     <MicrosoftNETHostModelVersion>5.0.0-preview.4.20213.12</MicrosoftNETHostModelVersion>
-    <PlatformAbstractionsVersion>$(MicrosoftDotNetPlatformAbstractionsPackageVersion)</PlatformAbstractionsVersion>
     <MicrosoftExtensionsDependencyModelVersion>$(MicrosoftExtensionsDependencyModelPackageVersion)</MicrosoftExtensionsDependencyModelVersion>
   </PropertyGroup>
   <PropertyGroup>
@@ -133,6 +130,7 @@
   <PropertyGroup>
     <FluentAssertionsVersion>4.19.2</FluentAssertionsVersion>
     <FluentAssertionsJsonVersion>4.19.0</FluentAssertionsJsonVersion>
+    <MicrosoftDotNetXUnitExtensionsVersion>5.0.0-beta.20201.2</MicrosoftDotNetXUnitExtensionsVersion>
   </PropertyGroup>
   <PropertyGroup>
     <ExeExtension>.exe</ExeExtension>
diff --git a/src/Cli/Microsoft.DotNet.Cli.Utils/Constants.cs b/src/Cli/Microsoft.DotNet.Cli.Utils/Constants.cs
index 20a8cba23ef4..71edc1dc274d 100644
--- a/src/Cli/Microsoft.DotNet.Cli.Utils/Constants.cs
+++ b/src/Cli/Microsoft.DotNet.Cli.Utils/Constants.cs
@@ -1,18 +1,18 @@
 // Copyright (c) .NET Foundation and contributors. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
-using Microsoft.DotNet.PlatformAbstractions;
+using System.Runtime.InteropServices;
 
 namespace Microsoft.DotNet.Cli.Utils
 {
     public static class Constants
     {
-        private static Platform CurrentPlatform => RuntimeEnvironment.OperatingSystemPlatform;
         public const string DefaultConfiguration = "Debug";
 
         public static readonly string ProjectFileName = "project.json";
         public static readonly string DotConfigDirectoryName = ".config";
-        public static readonly string ExeSuffix = CurrentPlatform == Platform.Windows ? ".exe" : string.Empty;
+        public static readonly string ExeSuffix =
+            RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? ".exe" : string.Empty;
 
         public static readonly string BinDirectoryName = "bin";
         public static readonly string ObjDirectoryName = "obj";
diff --git a/src/Cli/Microsoft.DotNet.Cli.Utils/DangerousFileDetector.cs b/src/Cli/Microsoft.DotNet.Cli.Utils/DangerousFileDetector.cs
index 3dbc53af92a7..9c8925a8c06e 100644
--- a/src/Cli/Microsoft.DotNet.Cli.Utils/DangerousFileDetector.cs
+++ b/src/Cli/Microsoft.DotNet.Cli.Utils/DangerousFileDetector.cs
@@ -4,8 +4,6 @@
 using System;
 using System.IO;
 using System.Runtime.InteropServices;
-using Microsoft.DotNet.PlatformAbstractions;
-using RuntimeEnvironment = Microsoft.DotNet.PlatformAbstractions.RuntimeEnvironment;
 
 namespace Microsoft.DotNet.Cli.Utils
 {
@@ -13,7 +11,7 @@ internal class DangerousFileDetector : IDangerousFileDetector
     {
         public bool IsDangerous(string filePath)
         {
-            if (RuntimeEnvironment.OperatingSystemPlatform != Platform.Windows)
+            if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
             {
                 return false;
             }
diff --git a/src/Cli/Microsoft.DotNet.Cli.Utils/DotnetFiles.cs b/src/Cli/Microsoft.DotNet.Cli.Utils/DotnetFiles.cs
index 9e6a39533904..462107f00648 100644
--- a/src/Cli/Microsoft.DotNet.Cli.Utils/DotnetFiles.cs
+++ b/src/Cli/Microsoft.DotNet.Cli.Utils/DotnetFiles.cs
@@ -5,7 +5,6 @@
 using System.IO;
 using System.Reflection;
 using Microsoft.DotNet.Cli.Utils;
-using Microsoft.DotNet.PlatformAbstractions;
 
 namespace Microsoft.DotNet.Cli
 {
diff --git a/src/Cli/Microsoft.DotNet.Cli.Utils/EnvironmentProvider.cs b/src/Cli/Microsoft.DotNet.Cli.Utils/EnvironmentProvider.cs
index f0a9fefbe982..22365f3e99cd 100644
--- a/src/Cli/Microsoft.DotNet.Cli.Utils/EnvironmentProvider.cs
+++ b/src/Cli/Microsoft.DotNet.Cli.Utils/EnvironmentProvider.cs
@@ -5,7 +5,7 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using Microsoft.DotNet.PlatformAbstractions;
+using System.Runtime.InteropServices;
 
 namespace Microsoft.DotNet.Cli.Utils
 {
@@ -24,7 +24,7 @@ public IEnumerable<string> ExecutableExtensions
                 if (_executableExtensions == null)
                 {
 
-                    _executableExtensions = RuntimeEnvironment.OperatingSystemPlatform == Platform.Windows
+                    _executableExtensions = RuntimeInformation.IsOSPlatform(OSPlatform.Windows)
                         ? Environment.GetEnvironmentVariable("PATHEXT")
                             .Split(';')
                             .Select(e => e.ToLower().Trim('"'))
@@ -41,7 +41,7 @@ private IEnumerable<string> SearchPaths
             {
                 if (_searchPaths == null)
                 {
-                    var searchPaths = new List<string> { ApplicationEnvironment.ApplicationBasePath };
+                    var searchPaths = new List<string> { AppContext.BaseDirectory };
 
                     searchPaths.AddRange(Environment
                         .GetEnvironmentVariable("PATH")
diff --git a/src/Cli/Microsoft.DotNet.Cli.Utils/FileNameSuffixes.cs b/src/Cli/Microsoft.DotNet.Cli.Utils/FileNameSuffixes.cs
index 48c149c740db..80ed0672f22c 100644
--- a/src/Cli/Microsoft.DotNet.Cli.Utils/FileNameSuffixes.cs
+++ b/src/Cli/Microsoft.DotNet.Cli.Utils/FileNameSuffixes.cs
@@ -2,7 +2,7 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 using System;
-using Microsoft.DotNet.PlatformAbstractions;
+using System.Runtime.InteropServices;
 
 namespace Microsoft.DotNet.Cli.Utils
 {
@@ -16,18 +16,25 @@ public static PlatformFileNameSuffixes CurrentPlatform
         {
             get
             {
-                switch (RuntimeEnvironment.OperatingSystemPlatform)
+                if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
                 {
-                    case Platform.Windows:
-                        return Windows;
-                    case Platform.Darwin:
-                        return OSX;
-                    case Platform.Linux:
-                        return Linux;
-                    case Platform.FreeBSD:
-                        return FreeBSD;
-                    default:
-                        throw new InvalidOperationException("Unknown Platform");
+                    return Windows;
+                }
+                else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
+                {
+                    return OSX;
+                }
+                else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
+                {
+                    return Linux;
+                }
+                else if (RuntimeInformation.IsOSPlatform(OSPlatform.Create("FREEBSD")))
+                {
+                    return FreeBSD;
+                }
+                else
+                {
+                    throw new InvalidOperationException("Unknown Platform");
                 }
             }
         }
diff --git a/src/Cli/Microsoft.DotNet.Cli.Utils/FrameworkDependencyFile.cs b/src/Cli/Microsoft.DotNet.Cli.Utils/FrameworkDependencyFile.cs
index b91f35fa0a2d..d8d7e75f3ac1 100644
--- a/src/Cli/Microsoft.DotNet.Cli.Utils/FrameworkDependencyFile.cs
+++ b/src/Cli/Microsoft.DotNet.Cli.Utils/FrameworkDependencyFile.cs
@@ -5,8 +5,7 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using Microsoft.DotNet.PlatformAbstractions;
-
+using System.Runtime.InteropServices;
 using Microsoft.Extensions.DependencyModel;
 
 namespace Microsoft.DotNet.Cli.Utils
@@ -28,11 +27,6 @@ public FrameworkDependencyFile()
             _dependencyContext = new Lazy<DependencyContext>(CreateDependencyContext);
         }
 
-        public bool SupportsCurrentRuntime()
-        {
-            return IsRuntimeSupported(RuntimeEnvironment.GetRuntimeIdentifier());
-        }
-
         public bool IsRuntimeSupported(string runtimeIdentifier)
         {
             return DependencyContext.RuntimeGraph.Any(g => g.Runtime == runtimeIdentifier);
@@ -46,18 +40,20 @@ public string GetNetStandardLibraryVersion()
                 ?.Version;
         }
 
+#if NETCOREAPP
         public bool TryGetMostFitRuntimeIdentifier(
             string alternativeCurrentRuntimeIdentifier,
             string[] candidateRuntimeIdentifiers,
             out string mostFitRuntimeIdentifier)
         {
             return TryGetMostFitRuntimeIdentifier(
-                RuntimeEnvironment.GetRuntimeIdentifier(),
+                RuntimeInformation.RuntimeIdentifier,
                 alternativeCurrentRuntimeIdentifier,
                 DependencyContext.RuntimeGraph,
                 candidateRuntimeIdentifiers,
                 out mostFitRuntimeIdentifier);
         }
+#endif
 
         internal static bool TryGetMostFitRuntimeIdentifier(
             string currentRuntimeIdentifier,
diff --git a/src/Cli/Microsoft.DotNet.Cli.Utils/Microsoft.DotNet.Cli.Utils.csproj b/src/Cli/Microsoft.DotNet.Cli.Utils/Microsoft.DotNet.Cli.Utils.csproj
index f48732109c52..556effc7b3ac 100644
--- a/src/Cli/Microsoft.DotNet.Cli.Utils/Microsoft.DotNet.Cli.Utils.csproj
+++ b/src/Cli/Microsoft.DotNet.Cli.Utils/Microsoft.DotNet.Cli.Utils.csproj
@@ -16,7 +16,6 @@
 
   <ItemGroup>
     <PackageReference Include="Microsoft.Extensions.DependencyModel" Version="$(MicrosoftExtensionsDependencyModelPackageVersion)" />
-    <PackageReference Include="Microsoft.DotNet.PlatformAbstractions" Version="$(MicrosoftDotNetPlatformAbstractionsPackageVersion)" />
     <PackageReference Include="NuGet.Versioning" Version="$(NuGetVersioningPackageVersion)" />
     <PackageReference Include="NuGet.Packaging" Version="$(NuGetPackagingPackageVersion)" />
     <!-- nuget moved all type from NuGet.Packaging.Core to NuGet.Packaging and added type forwarding in 5.0.0-rtm.5821.
diff --git a/src/Cli/Microsoft.DotNet.Cli.Utils/PathUtility.cs b/src/Cli/Microsoft.DotNet.Cli.Utils/PathUtility.cs
index df4ab26aad50..a071754d7bba 100644
--- a/src/Cli/Microsoft.DotNet.Cli.Utils/PathUtility.cs
+++ b/src/Cli/Microsoft.DotNet.Cli.Utils/PathUtility.cs
@@ -5,8 +5,8 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Runtime.InteropServices;
 using Microsoft.DotNet.Cli.Utils;
-using Microsoft.DotNet.PlatformAbstractions;
 
 namespace Microsoft.DotNet.Tools.Common
 {
@@ -152,7 +152,7 @@ public static string GetRelativePath(string path1, string path2, char separator,
             }
 
             StringComparison compare;
-            if (RuntimeEnvironment.OperatingSystemPlatform == Platform.Windows)
+            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
             {
                 compare = StringComparison.OrdinalIgnoreCase;
                 // check if paths are on the same volume
@@ -288,7 +288,7 @@ public static string RemoveExtraPathSeparators(string path)
                     result = component;
 
                     // On Windows, manually append a separator for drive references because Path.Combine won't do so
-                    if (result.EndsWith(":") && RuntimeEnvironment.OperatingSystemPlatform == Platform.Windows)
+                    if (result.EndsWith(":") && RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
                     {
                         result += Path.DirectorySeparatorChar;
                     }
@@ -311,7 +311,7 @@ public static bool HasExtension(this string filePath, string extension)
         {
             var comparison = StringComparison.Ordinal;
 
-            if (RuntimeEnvironment.OperatingSystemPlatform == Platform.Windows)
+            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
             {
                 comparison = StringComparison.OrdinalIgnoreCase;
             }
diff --git a/src/Cli/Microsoft.DotNet.Cli.Utils/ProcessReaper.cs b/src/Cli/Microsoft.DotNet.Cli.Utils/ProcessReaper.cs
index 864d8d115c31..3fb03626e6df 100644
--- a/src/Cli/Microsoft.DotNet.Cli.Utils/ProcessReaper.cs
+++ b/src/Cli/Microsoft.DotNet.Cli.Utils/ProcessReaper.cs
@@ -1,13 +1,12 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
 using System;
-using System.ComponentModel;
 using System.Diagnostics;
 using System.Runtime.InteropServices;
 using System.Threading;
-using Microsoft.DotNet.PlatformAbstractions;
 using Microsoft.Win32.SafeHandles;
 
-using RuntimeEnvironment = Microsoft.DotNet.PlatformAbstractions.RuntimeEnvironment;
-
 namespace Microsoft.DotNet.Cli.Utils
 {
     /// <summary>
@@ -37,7 +36,7 @@ public ProcessReaper(Process process)
             // where the child writes output the test expects before the intermediate dotnet process
             // has registered the event handlers to handle the signals the tests will generate.
             Console.CancelKeyPress += HandleCancelKeyPress;
-            if (RuntimeEnvironment.OperatingSystemPlatform != Platform.Windows)
+            if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
             {
                 _shutdownMutex = new Mutex();
                 AppDomain.CurrentDomain.ProcessExit += HandleProcessExit;
@@ -49,7 +48,7 @@ public ProcessReaper(Process process)
         /// </summary>
         public void NotifyProcessStarted()
         {
-            if (RuntimeEnvironment.OperatingSystemPlatform == Platform.Windows)
+            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
             {
                 // Limit the use of job objects to versions of Windows that support nested jobs (i.e. Windows 8/2012 or later).
                 // Ideally, we would check for some new API export or OS feature instead of the OS version,
@@ -66,7 +65,7 @@ public void NotifyProcessStarted()
 
         public void Dispose()
         {
-            if (RuntimeEnvironment.OperatingSystemPlatform == Platform.Windows)
+            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
             {
                 if (_job != null)
                 {
diff --git a/src/Cli/Microsoft.DotNet.Cli.Utils/RuntimeEnvironment.cs b/src/Cli/Microsoft.DotNet.Cli.Utils/RuntimeEnvironment.cs
new file mode 100644
index 000000000000..13d47863db3f
--- /dev/null
+++ b/src/Cli/Microsoft.DotNet.Cli.Utils/RuntimeEnvironment.cs
@@ -0,0 +1,372 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.IO;
+using System.Runtime.InteropServices;
+
+namespace Microsoft.DotNet.Cli.Utils
+{
+    internal enum Platform
+    {
+        Unknown = 0,
+        Windows = 1,
+        Linux = 2,
+        Darwin = 3,
+        FreeBSD = 4
+    }
+
+    internal static class RuntimeEnvironment
+    {
+        private static readonly string OverrideEnvironmentVariableName = "DOTNET_RUNTIME_ID";
+
+        private static readonly Lazy<Platform> _platform = new Lazy<Platform>(DetermineOSPlatform);
+        private static readonly Lazy<DistroInfo> _distroInfo = new Lazy<DistroInfo>(LoadDistroInfo);
+
+        public static Platform OperatingSystemPlatform { get; } = GetOSPlatform();
+        public static string OperatingSystemVersion { get; } = GetOSVersion();
+        public static string OperatingSystem { get; } = GetOSName();
+
+        public static string GetRuntimeIdentifier()
+        {
+            return
+                Environment.GetEnvironmentVariable(OverrideEnvironmentVariableName) ??
+                (GetRIDOS() + GetRIDVersion() + GetRIDArch());
+        }
+
+        private static string GetRIDArch()
+        {
+            return $"-{RuntimeInformation.ProcessArchitecture.ToString().ToLowerInvariant()}";
+        }
+
+        private static string GetRIDVersion()
+        {
+            // Windows RIDs do not separate OS name and version by "." due to legacy
+            // Others do, that's why we have the "." prefix on them below
+            switch (OperatingSystemPlatform)
+            {
+                case Platform.Windows:
+                    return GetWindowsProductVersion();
+                case Platform.Linux:
+                    if (string.IsNullOrEmpty(OperatingSystemVersion))
+                    {
+                        return string.Empty;
+                    }
+
+                    return $".{OperatingSystemVersion}";
+                case Platform.Darwin:
+                    return $".{OperatingSystemVersion}";
+                case Platform.FreeBSD:
+                    return $".{OperatingSystemVersion}";
+                default:
+                    return string.Empty; // Unknown Platform? Unknown Version!
+            }
+        }
+
+        private static string GetWindowsProductVersion()
+        {
+            var ver = Version.Parse(OperatingSystemVersion);
+            if (ver.Major == 6)
+            {
+                if (ver.Minor == 1)
+                {
+                    return "7";
+                }
+                else if (ver.Minor == 2)
+                {
+                    return "8";
+                }
+                else if (ver.Minor == 3)
+                {
+                    return "81";
+                }
+            }
+            else if (ver.Major >= 10)
+            {
+                // Return the major version for use in RID computation without applying any cap.
+                return ver.Major.ToString();
+            }
+            return string.Empty; // Unknown version
+        }
+
+        private static string GetRIDOS()
+        {
+            switch (OperatingSystemPlatform)
+            {
+                case Platform.Windows:
+                    return "win";
+                case Platform.Linux:
+                    return OperatingSystem.ToLowerInvariant();
+                case Platform.Darwin:
+                    return "osx";
+                case Platform.FreeBSD:
+                    return "freebsd";
+                default:
+                    return "unknown";
+            }
+        }
+
+        private class DistroInfo
+        {
+            public string Id;
+            public string VersionId;
+        }
+
+        public static string GetOSName()
+        {
+            switch (GetOSPlatform())
+            {
+                case Platform.Windows:
+                    return "Windows";
+                case Platform.Linux:
+                    return GetDistroId() ?? "Linux";
+                case Platform.Darwin:
+                    return "Mac OS X";
+                case Platform.FreeBSD:
+                    return "FreeBSD";
+                default:
+                    return "Unknown";
+            }
+        }
+
+        public static string GetOSVersion()
+        {
+            switch (GetOSPlatform())
+            {
+                case Platform.Windows:
+                    return NativeMethods.Windows.RtlGetVersion() ?? string.Empty;
+                case Platform.Linux:
+                    return GetDistroVersionId() ?? string.Empty;
+                case Platform.Darwin:
+                    return GetDarwinVersion() ?? string.Empty;
+                case Platform.FreeBSD:
+                    return GetFreeBSDVersion() ?? string.Empty;
+                default:
+                    return string.Empty;
+            }
+        }
+
+        private static string GetDarwinVersion()
+        {
+            Version version;
+            var kernelRelease = NativeMethods.Darwin.GetKernelRelease();
+            if (!Version.TryParse(kernelRelease, out version) || version.Major < 5)
+            {
+                // 10.0 covers all versions prior to Darwin 5
+                // Similarly, if the version is not a valid version number, but we have still detected that it is Darwin, we just assume
+                // it is OS X 10.0
+                return "10.0";
+            }
+            else
+            {
+                // Mac OS X 10.1 mapped to Darwin 5.x, and the mapping continues that way
+                // So just subtract 4 from the Darwin version.
+                // https://en.wikipedia.org/wiki/Darwin_%28operating_system%29
+                return $"10.{version.Major - 4}";
+            }
+        }
+
+        private static string GetFreeBSDVersion()
+        {
+            // This is same as sysctl kern.version
+            // FreeBSD 11.0-RELEASE-p1 FreeBSD 11.0-RELEASE-p1 #0 r306420: Thu Sep 29 01:43:23 UTC 2016     root@releng2.nyi.freebsd.org:/usr/obj/usr/src/sys/GENERIC
+            // What we want is major release as minor releases should be compatible.
+            String version = RuntimeInformation.OSDescription;
+            try
+            {
+                // second token up to first dot
+                return RuntimeInformation.OSDescription.Split()[1].Split('.')[0];
+            }
+            catch
+            {
+            }
+            return string.Empty;
+        }
+
+        public static Platform GetOSPlatform()
+        {
+            return _platform.Value;
+        }
+
+        private static string GetDistroId()
+        {
+            return _distroInfo.Value?.Id;
+        }
+
+        private static string GetDistroVersionId()
+        {
+            return _distroInfo.Value?.VersionId;
+        }
+
+        private static DistroInfo LoadDistroInfo()
+        {
+            DistroInfo result = null;
+
+            // Sample os-release file:
+            //   NAME="Ubuntu"
+            //   VERSION = "14.04.3 LTS, Trusty Tahr"
+            //   ID = ubuntu
+            //   ID_LIKE = debian
+            //   PRETTY_NAME = "Ubuntu 14.04.3 LTS"
+            //   VERSION_ID = "14.04"
+            //   HOME_URL = "http://www.ubuntu.com/"
+            //   SUPPORT_URL = "http://help.ubuntu.com/"
+            //   BUG_REPORT_URL = "http://bugs.launchpad.net/ubuntu/"
+            // We use ID and VERSION_ID
+
+            if (File.Exists("/etc/os-release"))
+            {
+                var lines = File.ReadAllLines("/etc/os-release");
+                result = new DistroInfo();
+                foreach (var line in lines)
+                {
+                    if (line.StartsWith("ID=", StringComparison.Ordinal))
+                    {
+                        result.Id = line.Substring(3).Trim('"', '\'');
+                    }
+                    else if (line.StartsWith("VERSION_ID=", StringComparison.Ordinal))
+                    {
+                        result.VersionId = line.Substring(11).Trim('"', '\'');
+                    }
+                }
+            }
+
+            if (result != null)
+            {
+                result = NormalizeDistroInfo(result);
+            }
+
+            return result;
+        }
+
+        // For some distros, we don't want to use the full version from VERSION_ID. One example is
+        // Red Hat Enterprise Linux, which includes a minor version in their VERSION_ID but minor
+        // versions are backwards compatable.
+        //
+        // In this case, we'll normalized RIDs like 'rhel.7.2' and 'rhel.7.3' to a generic
+        // 'rhel.7'. This brings RHEL in line with other distros like CentOS or Debian which
+        // don't put minor version numbers in their VERSION_ID fields because all minor versions
+        // are backwards compatible.
+        private static DistroInfo NormalizeDistroInfo(DistroInfo distroInfo)
+        {
+            // Handle if VersionId is null by just setting the index to -1.
+            int lastVersionNumberSeparatorIndex = distroInfo.VersionId?.IndexOf('.') ?? -1;
+
+            if (lastVersionNumberSeparatorIndex != -1 && distroInfo.Id == "alpine")
+            {
+                // For Alpine, the version reported has three components, so we need to find the second version separator
+                lastVersionNumberSeparatorIndex = distroInfo.VersionId.IndexOf('.', lastVersionNumberSeparatorIndex + 1);
+            }
+
+            if (lastVersionNumberSeparatorIndex != -1 && (distroInfo.Id == "rhel" || distroInfo.Id == "alpine"))
+            {
+                distroInfo.VersionId = distroInfo.VersionId.Substring(0, lastVersionNumberSeparatorIndex);
+            }
+
+            return distroInfo;
+        }
+
+        private static Platform DetermineOSPlatform()
+        {
+            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+            {
+                return Platform.Windows;
+            }
+            if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
+            {
+                return Platform.Linux;
+            }
+            if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
+            {
+                return Platform.Darwin;
+            }
+            if (RuntimeInformation.IsOSPlatform(OSPlatform.Create("FREEBSD")))
+            {
+                return Platform.FreeBSD;
+            }
+
+            return Platform.Unknown;
+        }
+
+        private static class NativeMethods
+        {
+            public static class Darwin
+            {
+                private const int CTL_KERN = 1;
+                private const int KERN_OSRELEASE = 2;
+
+                public unsafe static string GetKernelRelease()
+                {
+                    const uint BUFFER_LENGTH = 32;
+
+                    var name = stackalloc int[2];
+                    name[0] = CTL_KERN;
+                    name[1] = KERN_OSRELEASE;
+
+                    var buf = stackalloc byte[(int)BUFFER_LENGTH];
+                    var len = stackalloc uint[1];
+                    *len = BUFFER_LENGTH;
+
+                    try
+                    {
+                        // If the buffer isn't big enough, it seems sysctl still returns 0 and just sets len to the
+                        // necessary buffer size. This appears to be contrary to the man page, but it's easy to detect
+                        // by simply checking len against the buffer length.
+                        if (sysctl(name, 2, buf, len, IntPtr.Zero, 0) == 0 && *len < BUFFER_LENGTH)
+                        {
+                            return Marshal.PtrToStringAnsi((IntPtr)buf, (int)*len);
+                        }
+                    }
+                    catch (Exception ex)
+                    {
+                        throw new PlatformNotSupportedException("Error reading Darwin Kernel Version", ex);
+                    }
+                    throw new PlatformNotSupportedException("Unknown error reading Darwin Kernel Version");
+                }
+
+                [DllImport("libc")]
+                private unsafe static extern int sysctl(
+                    int* name,
+                    uint namelen,
+                    byte* oldp,
+                    uint* oldlenp,
+                    IntPtr newp,
+                    uint newlen);
+            }
+
+            public static class Windows
+            {
+                [StructLayout(LayoutKind.Sequential)]
+                internal struct RTL_OSVERSIONINFOEX
+                {
+                    internal uint dwOSVersionInfoSize;
+                    internal uint dwMajorVersion;
+                    internal uint dwMinorVersion;
+                    internal uint dwBuildNumber;
+                    internal uint dwPlatformId;
+                    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 128)]
+                    internal string szCSDVersion;
+                }
+
+                // This call avoids the shimming Windows does to report old versions
+                [DllImport("ntdll")]
+                private static extern int RtlGetVersion(out RTL_OSVERSIONINFOEX lpVersionInformation);
+
+                internal static string RtlGetVersion()
+                {
+                    RTL_OSVERSIONINFOEX osvi = new RTL_OSVERSIONINFOEX();
+                    osvi.dwOSVersionInfoSize = (uint)Marshal.SizeOf(osvi);
+                    if (RtlGetVersion(out osvi) == 0)
+                    {
+                        return $"{osvi.dwMajorVersion}.{osvi.dwMinorVersion}.{osvi.dwBuildNumber}";
+                    }
+                    else
+                    {
+                        return null;
+                    }
+                }
+            }
+        }
+
+    }
+}
diff --git a/src/Cli/Microsoft.DotNet.Cli.Utils/RuntimeEnvironmentRidExtensions.cs b/src/Cli/Microsoft.DotNet.Cli.Utils/RuntimeEnvironmentRidExtensions.cs
deleted file mode 100644
index 9ae45b33d623..000000000000
--- a/src/Cli/Microsoft.DotNet.Cli.Utils/RuntimeEnvironmentRidExtensions.cs
+++ /dev/null
@@ -1,33 +0,0 @@
-// Copyright (c) .NET Foundation and contributors. All rights reserved.
-// Licensed under the MIT license. See LICENSE file in the project root for full license information.
-
-
-using System;
-using System.Collections.Generic;
-using Microsoft.DotNet.PlatformAbstractions;
-
-namespace Microsoft.DotNet.Cli.Utils
-{
-    // This is to support some legacy stuff.
-    // dnu restore (and thus dotnet restore) always uses win7-x64 as the Windows restore target,
-    // so, when picking targets out of the lock file, we need to do version fallback since the
-    // active RID might be higher than the RID in the lock file.
-    //
-    // We should clean this up. Filed #619 to track.
-    public static class RuntimeEnvironmentRidExtensions
-    {
-        // Gets the identifier that is used for restore by default (this is different from the actual RID, but only on Windows)
-        public static string GetLegacyRestoreRuntimeIdentifier()
-        {
-            if (RuntimeEnvironment.OperatingSystemPlatform != Platform.Windows)
-            {
-                return RuntimeEnvironment.GetRuntimeIdentifier();
-            }
-            else
-            {
-                var arch = RuntimeEnvironment.RuntimeArchitecture.ToLowerInvariant();
-                return "win7-" + arch;
-            }
-        }
-    }
-}
diff --git a/src/Cli/dotnet/CommandFactory/CommandResolution/AppBaseCommandResolver.cs b/src/Cli/dotnet/CommandFactory/CommandResolution/AppBaseCommandResolver.cs
index da87aacd2299..a9d8f896b390 100644
--- a/src/Cli/dotnet/CommandFactory/CommandResolution/AppBaseCommandResolver.cs
+++ b/src/Cli/dotnet/CommandFactory/CommandResolution/AppBaseCommandResolver.cs
@@ -1,8 +1,8 @@
 // Copyright (c) .NET Foundation and contributors. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
+using System;
 using Microsoft.DotNet.Cli.Utils;
-using Microsoft.DotNet.PlatformAbstractions;
 
 namespace Microsoft.DotNet.CommandFactory
 {
@@ -14,7 +14,7 @@ public AppBaseCommandResolver(IEnvironmentProvider environment,
         internal override string ResolveCommandPath(CommandResolverArguments commandResolverArguments)
         {
             return _environment.GetCommandPathFromRootPath(
-                ApplicationEnvironment.ApplicationBasePath,
+                AppContext.BaseDirectory,
                 commandResolverArguments.CommandName);
         }
     }
diff --git a/src/Cli/dotnet/CommandFactory/CommandResolution/AppBaseDllCommandResolver.cs b/src/Cli/dotnet/CommandFactory/CommandResolution/AppBaseDllCommandResolver.cs
index 10286e2f16d6..bd946e608ed6 100644
--- a/src/Cli/dotnet/CommandFactory/CommandResolution/AppBaseDllCommandResolver.cs
+++ b/src/Cli/dotnet/CommandFactory/CommandResolution/AppBaseDllCommandResolver.cs
@@ -1,10 +1,10 @@
 // Copyright (c) .NET Foundation and contributors. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
+using System;
 using System.IO;
 using System.Linq;
 using Microsoft.DotNet.Cli.Utils;
-using Microsoft.DotNet.PlatformAbstractions;
 
 namespace Microsoft.DotNet.CommandFactory
 {
@@ -18,7 +18,7 @@ public CommandSpec Resolve(CommandResolverArguments commandResolverArguments)
             }
             if (commandResolverArguments.CommandName.EndsWith(FileNameSuffixes.DotNet.DynamicLib))
             {
-                var localPath = Path.Combine(ApplicationEnvironment.ApplicationBasePath,
+                var localPath = Path.Combine(AppContext.BaseDirectory,
                     commandResolverArguments.CommandName);
                 if (File.Exists(localPath))
                 {
diff --git a/src/Cli/dotnet/CommandFactory/CommandResolution/DefaultCommandResolverPolicy.cs b/src/Cli/dotnet/CommandFactory/CommandResolution/DefaultCommandResolverPolicy.cs
index 088a258b2034..7f0c31129e89 100644
--- a/src/Cli/dotnet/CommandFactory/CommandResolution/DefaultCommandResolverPolicy.cs
+++ b/src/Cli/dotnet/CommandFactory/CommandResolution/DefaultCommandResolverPolicy.cs
@@ -1,8 +1,8 @@
 // Copyright (c) .NET Foundation and contributors. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
+using System.Runtime.InteropServices;
 using Microsoft.DotNet.Cli.Utils;
-using Microsoft.DotNet.PlatformAbstractions;
 
 namespace Microsoft.DotNet.CommandFactory
 {
@@ -20,7 +20,7 @@ public static CompositeCommandResolver Create()
             var publishedPathCommandSpecFactory = new PublishPathCommandSpecFactory();
 
             var platformCommandSpecFactory = default(IPlatformCommandSpecFactory);
-            if (RuntimeEnvironment.OperatingSystemPlatform == Platform.Windows)
+            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
             {
                 platformCommandSpecFactory = new WindowsExePreferredCommandSpecFactory();
             }
diff --git a/src/Cli/dotnet/CommandFactory/CommandResolution/DotnetToolsCommandResolver.cs b/src/Cli/dotnet/CommandFactory/CommandResolution/DotnetToolsCommandResolver.cs
index a3a2b8d8c53d..e4a4e5f901a5 100644
--- a/src/Cli/dotnet/CommandFactory/CommandResolution/DotnetToolsCommandResolver.cs
+++ b/src/Cli/dotnet/CommandFactory/CommandResolution/DotnetToolsCommandResolver.cs
@@ -3,10 +3,6 @@
 
 using System;
 using System.IO;
-using System.Reflection;
-using System.Collections.Generic;
-using Microsoft.DotNet.Cli.Utils;
-using Microsoft.DotNet.PlatformAbstractions;
 
 namespace Microsoft.DotNet.CommandFactory
 {
@@ -18,7 +14,7 @@ public DotnetToolsCommandResolver(string dotnetToolPath = null)
         {
             if (dotnetToolPath == null)
             {
-                _dotnetToolPath = Path.Combine(ApplicationEnvironment.ApplicationBasePath,
+                _dotnetToolPath = Path.Combine(AppContext.BaseDirectory,
                     "DotnetTools");
             }
             else
diff --git a/src/Cli/dotnet/CommandFactory/CommandResolution/LocalToolsCommandResolver.cs b/src/Cli/dotnet/CommandFactory/CommandResolution/LocalToolsCommandResolver.cs
index 59af70475511..1b6c0b372eaf 100644
--- a/src/Cli/dotnet/CommandFactory/CommandResolution/LocalToolsCommandResolver.cs
+++ b/src/Cli/dotnet/CommandFactory/CommandResolution/LocalToolsCommandResolver.cs
@@ -3,15 +3,12 @@
 
 using System;
 using System.IO;
-using System.Reflection;
-using System.Collections.Generic;
+using Microsoft.DotNet.Cli;
 using Microsoft.DotNet.Cli.Utils;
-using Microsoft.DotNet.PlatformAbstractions;
 using Microsoft.DotNet.ToolManifest;
 using Microsoft.DotNet.ToolPackage;
-using NuGet.Frameworks;
-using Microsoft.DotNet.Cli;
 using Microsoft.Extensions.EnvironmentAbstractions;
+using NuGet.Frameworks;
 
 namespace Microsoft.DotNet.CommandFactory
 {
diff --git a/src/Cli/dotnet/CommandFactory/CommandResolution/PathCommandResolverPolicy.cs b/src/Cli/dotnet/CommandFactory/CommandResolution/PathCommandResolverPolicy.cs
index afe9324c078b..b9bbfb2796f8 100644
--- a/src/Cli/dotnet/CommandFactory/CommandResolution/PathCommandResolverPolicy.cs
+++ b/src/Cli/dotnet/CommandFactory/CommandResolution/PathCommandResolverPolicy.cs
@@ -1,8 +1,8 @@
 // Copyright (c) .NET Foundation and contributors. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
+using System.Runtime.InteropServices;
 using Microsoft.DotNet.Cli.Utils;
-using Microsoft.DotNet.PlatformAbstractions;
 
 namespace Microsoft.DotNet.CommandFactory
 {
@@ -18,7 +18,7 @@ public static CompositeCommandResolver Create()
             var environment = new EnvironmentProvider();
 
             var platformCommandSpecFactory = default(IPlatformCommandSpecFactory);
-            if (RuntimeEnvironment.OperatingSystemPlatform == Platform.Windows)
+            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
             {
                 platformCommandSpecFactory = new WindowsExePreferredCommandSpecFactory();
             }
diff --git a/src/Cli/dotnet/CommandFactory/CommandResolution/ScriptCommandResolverPolicy.cs b/src/Cli/dotnet/CommandFactory/CommandResolution/ScriptCommandResolverPolicy.cs
index 221b1a999d96..712be075e98e 100644
--- a/src/Cli/dotnet/CommandFactory/CommandResolution/ScriptCommandResolverPolicy.cs
+++ b/src/Cli/dotnet/CommandFactory/CommandResolution/ScriptCommandResolverPolicy.cs
@@ -1,8 +1,8 @@
 // Copyright (c) .NET Foundation and contributors. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
+using System.Runtime.InteropServices;
 using Microsoft.DotNet.Cli.Utils;
-using Microsoft.DotNet.PlatformAbstractions;
 
 namespace Microsoft.DotNet.CommandFactory
 {
@@ -13,7 +13,7 @@ public static CompositeCommandResolver Create()
             var environment = new EnvironmentProvider();
 
             var platformCommandSpecFactory = default(IPlatformCommandSpecFactory);
-            if (RuntimeEnvironment.OperatingSystemPlatform == Platform.Windows)
+            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
             {
                 platformCommandSpecFactory = new WindowsExePreferredCommandSpecFactory();
             }
diff --git a/src/Cli/dotnet/MulticoreJitProfilePathCalculator.cs b/src/Cli/dotnet/MulticoreJitProfilePathCalculator.cs
index 6faf51625d88..1e832b0921a2 100644
--- a/src/Cli/dotnet/MulticoreJitProfilePathCalculator.cs
+++ b/src/Cli/dotnet/MulticoreJitProfilePathCalculator.cs
@@ -5,7 +5,6 @@
 using System.IO;
 using System.Runtime.InteropServices;
 using Microsoft.DotNet.Cli.Utils;
-using Microsoft.DotNet.PlatformAbstractions;
 
 namespace Microsoft.DotNet.Cli
 {
@@ -32,7 +31,7 @@ private void CalculateProfileRootPath()
 
             var version = Product.Version;
 
-            var rid = PlatformAbstractions.RuntimeEnvironment.GetRuntimeIdentifier();
+            var rid = RuntimeInformation.RuntimeIdentifier;
 
             _multicoreJitProfilePath = Path.Combine(profileRoot, "optimizationdata", version, rid);
         }
diff --git a/src/Cli/dotnet/Program.cs b/src/Cli/dotnet/Program.cs
index 9d739fc3b853..b31bc63885e7 100644
--- a/src/Cli/dotnet/Program.cs
+++ b/src/Cli/dotnet/Program.cs
@@ -10,16 +10,14 @@
 using Microsoft.DotNet.Cli.CommandLine;
 using Microsoft.DotNet.Cli.Telemetry;
 using Microsoft.DotNet.Cli.Utils;
+using Microsoft.DotNet.CommandFactory;
 using Microsoft.DotNet.Configurer;
-using Microsoft.DotNet.PlatformAbstractions;
 using Microsoft.DotNet.ShellShim;
 using Microsoft.DotNet.Tools.Help;
 using Microsoft.Extensions.EnvironmentAbstractions;
 using NuGet.Frameworks;
-using Command = Microsoft.DotNet.Cli.Utils.Command;
-using RuntimeEnvironment = Microsoft.DotNet.PlatformAbstractions.RuntimeEnvironment;
 using LocalizableStrings = Microsoft.DotNet.Cli.Utils.LocalizableStrings;
-using Microsoft.DotNet.CommandFactory;
+using RuntimeEnvironment = Microsoft.DotNet.Cli.Utils.RuntimeEnvironment;
 
 namespace Microsoft.DotNet.Cli
 {
@@ -318,7 +316,7 @@ private static void PrintInfo()
             Reporter.Output.WriteLine($" OS Version:  {RuntimeEnvironment.OperatingSystemVersion}");
             Reporter.Output.WriteLine($" OS Platform: {RuntimeEnvironment.OperatingSystemPlatform}");
             Reporter.Output.WriteLine($" RID:         {GetDisplayRid(versionFile)}");
-            Reporter.Output.WriteLine($" Base Path:   {ApplicationEnvironment.ApplicationBasePath}");
+            Reporter.Output.WriteLine($" Base Path:   {AppContext.BaseDirectory}");
         }
 
         private static bool IsArg(string candidate, string longName)
@@ -336,7 +334,7 @@ private static string GetDisplayRid(DotnetVersionFile versionFile)
         {
             FrameworkDependencyFile fxDepsFile = new FrameworkDependencyFile();
 
-            string currentRid = RuntimeEnvironment.GetRuntimeIdentifier();
+            string currentRid = RuntimeInformation.RuntimeIdentifier;
 
             // if the current RID isn't supported by the shared framework, display the RID the CLI was
             // built with instead, so the user knows which RID they should put in their "runtimes" section.
diff --git a/src/Cli/dotnet/ShellShim/AppHostShimMaker.cs b/src/Cli/dotnet/ShellShim/AppHostShimMaker.cs
index d30e7562ebae..580b70bf348d 100644
--- a/src/Cli/dotnet/ShellShim/AppHostShimMaker.cs
+++ b/src/Cli/dotnet/ShellShim/AppHostShimMaker.cs
@@ -1,9 +1,9 @@
 // Copyright (c) .NET Foundation and contributors. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
+using System;
 using System.IO;
 using System.Runtime.InteropServices;
-using Microsoft.DotNet.PlatformAbstractions;
 using Microsoft.DotNet.Tools;
 using Microsoft.Extensions.EnvironmentAbstractions;
 using Microsoft.NET.HostModel;
@@ -22,7 +22,7 @@ public AppHostShellShimMaker(string appHostSourceDirectory = null, IFilePermissi
         {
             _appHostSourceDirectory =
                 appHostSourceDirectory
-                ?? Path.Combine(ApplicationEnvironment.ApplicationBasePath, "AppHostTemplate");
+                ?? Path.Combine(AppContext.BaseDirectory, "AppHostTemplate");
 
             _filePermissionSetter =
                 filePermissionSetter
diff --git a/src/Cli/dotnet/ShellShim/ShellShimRepository.cs b/src/Cli/dotnet/ShellShim/ShellShimRepository.cs
index 8217929b0147..c33581636386 100644
--- a/src/Cli/dotnet/ShellShim/ShellShimRepository.cs
+++ b/src/Cli/dotnet/ShellShim/ShellShimRepository.cs
@@ -8,9 +8,7 @@
 using System.Runtime.InteropServices;
 using Microsoft.DotNet.Cli;
 using Microsoft.DotNet.Cli.Utils;
-using Microsoft.DotNet.PlatformAbstractions;
 using Microsoft.DotNet.Tools;
-using Microsoft.DotNet.Tools.Common;
 using Microsoft.Extensions.EnvironmentAbstractions;
 
 namespace Microsoft.DotNet.ShellShim
diff --git a/src/Cli/dotnet/Telemetry/DockerContainerDetectorForTelemetry.cs b/src/Cli/dotnet/Telemetry/DockerContainerDetectorForTelemetry.cs
index b06250f7581c..8edfb3a24f33 100644
--- a/src/Cli/dotnet/Telemetry/DockerContainerDetectorForTelemetry.cs
+++ b/src/Cli/dotnet/Telemetry/DockerContainerDetectorForTelemetry.cs
@@ -2,9 +2,9 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 using System.IO;
+using System.Runtime.InteropServices;
 using System.Security;
 using Microsoft.Win32;
-using Microsoft.DotNet.PlatformAbstractions;
 
 namespace Microsoft.DotNet.Cli.Telemetry
 {
@@ -12,32 +12,36 @@ internal class DockerContainerDetectorForTelemetry : IDockerContainerDetector
     {
         public IsDockerContainer IsDockerContainer()
         {
-            switch (RuntimeEnvironment.OperatingSystemPlatform)
+            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
             {
-                case Platform.Windows:
-                    try
+                try
+                {
+                    using (RegistryKey subkey
+                        = Registry.LocalMachine.OpenSubKey("System\\CurrentControlSet\\Control"))
                     {
-                        using (RegistryKey subkey
-                            = Registry.LocalMachine.OpenSubKey("System\\CurrentControlSet\\Control"))
-                        {
-                            return subkey?.GetValue("ContainerType") != null
-                                ? Cli.Telemetry.IsDockerContainer.True
-                                : Cli.Telemetry.IsDockerContainer.False;
-                        }
+                        return subkey?.GetValue("ContainerType") != null
+                            ? Cli.Telemetry.IsDockerContainer.True
+                            : Cli.Telemetry.IsDockerContainer.False;
                     }
-                    catch (SecurityException)
-                    {
-                        return Cli.Telemetry.IsDockerContainer.Unknown;
-                    }
-                case Platform.Linux:
-                    return ReadProcToDetectDockerInLinux()
-                        ? Cli.Telemetry.IsDockerContainer.True
-                        : Cli.Telemetry.IsDockerContainer.False;
-                case Platform.Unknown:
+                }
+                catch (SecurityException)
+                {
                     return Cli.Telemetry.IsDockerContainer.Unknown;
-                case Platform.Darwin:
-                default:
-                    return Cli.Telemetry.IsDockerContainer.False;
+                }
+            }
+            else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
+            {
+                return ReadProcToDetectDockerInLinux()
+                    ? Cli.Telemetry.IsDockerContainer.True
+                    : Cli.Telemetry.IsDockerContainer.False;
+            }
+            else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
+            {
+                return Cli.Telemetry.IsDockerContainer.False;
+            }
+            else
+            {
+                return Cli.Telemetry.IsDockerContainer.Unknown;
             }
         }
 
diff --git a/src/Cli/dotnet/Telemetry/ExternalTelemetryProperties.cs b/src/Cli/dotnet/Telemetry/ExternalTelemetryProperties.cs
index 42a2ad9fcada..a5550c82cfbf 100644
--- a/src/Cli/dotnet/Telemetry/ExternalTelemetryProperties.cs
+++ b/src/Cli/dotnet/Telemetry/ExternalTelemetryProperties.cs
@@ -2,13 +2,9 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 using System;
-using System.Collections.Generic;
 using System.Globalization;
-using System.IO;
 using System.Security;
-using Microsoft.DotNet.PlatformAbstractions;
 using Microsoft.Win32;
-using RuntimeEnvironment = Microsoft.DotNet.PlatformAbstractions.RuntimeEnvironment;
 using System.Runtime.InteropServices;
 using System.Diagnostics;
 
@@ -24,7 +20,7 @@ internal static class ExternalTelemetryProperties
         /// </summary>
         internal static string GetInstallationType()
         {
-            if (RuntimeEnvironment.OperatingSystemPlatform != Platform.Windows)
+            if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
             {
                 return "";
             }
@@ -56,7 +52,7 @@ internal static string GetInstallationType()
         /// </summary>
         internal static string GetProductType()
         {
-            if (RuntimeEnvironment.OperatingSystemPlatform != Platform.Windows)
+            if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
             {
                 return "";
             }
@@ -90,7 +86,7 @@ internal static string GetProductType()
         /// </summary>
         internal static string GetLibcRelease()
         {
-            if (RuntimeEnvironment.OperatingSystemPlatform == Platform.Windows)
+            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
             {
                 return "";
             }
@@ -114,7 +110,7 @@ internal static string GetLibcRelease()
         /// </summary>
         internal static string GetLibcVersion()
         {
-            if (RuntimeEnvironment.OperatingSystemPlatform == Platform.Windows)
+            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
             {
                 return "";
             }
@@ -131,4 +127,4 @@ internal static string GetLibcVersion()
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/Cli/dotnet/Telemetry/Telemetry.cs b/src/Cli/dotnet/Telemetry/Telemetry.cs
index ae58897f88e4..b4171caaf03b 100644
--- a/src/Cli/dotnet/Telemetry/Telemetry.cs
+++ b/src/Cli/dotnet/Telemetry/Telemetry.cs
@@ -4,14 +4,11 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
-using System.IO;
 using System.Threading.Tasks;
 using Microsoft.ApplicationInsights;
 using Microsoft.ApplicationInsights.Extensibility;
 using Microsoft.DotNet.Cli.Utils;
 using Microsoft.DotNet.Configurer;
-using Microsoft.DotNet.PlatformAbstractions;
-using Microsoft.DotNet.Cli.Telemetry.PersistenceChannel;
 
 namespace Microsoft.DotNet.Cli.Telemetry
 {
diff --git a/src/Cli/dotnet/Telemetry/TelemetryCommonProperties.cs b/src/Cli/dotnet/Telemetry/TelemetryCommonProperties.cs
index 782c3e33b8e8..6973c09bf308 100644
--- a/src/Cli/dotnet/Telemetry/TelemetryCommonProperties.cs
+++ b/src/Cli/dotnet/Telemetry/TelemetryCommonProperties.cs
@@ -3,17 +3,11 @@
 
 using System;
 using System.Collections.Generic;
-using Microsoft.DotNet.Cli.Utils;
-using Microsoft.DotNet.PlatformAbstractions;
 using System.IO;
-using System.Security;
+using Microsoft.DotNet.Cli.Utils;
 using Microsoft.DotNet.Configurer;
-using Microsoft.Win32;
-using System.Linq;
-using RuntimeEnvironment = Microsoft.DotNet.PlatformAbstractions.RuntimeEnvironment;
+using RuntimeEnvironment = Microsoft.DotNet.Cli.Utils.RuntimeEnvironment;
 using RuntimeInformation = System.Runtime.InteropServices.RuntimeInformation;
-using System.Runtime.InteropServices;
-using System.Diagnostics;
 
 namespace Microsoft.DotNet.Cli.Telemetry
 {
@@ -66,7 +60,7 @@ public Dictionary<string, string> GetTelemetryCommonProperties()
                 {OSVersion, RuntimeEnvironment.OperatingSystemVersion},
                 {OSPlatform, RuntimeEnvironment.OperatingSystemPlatform.ToString()},
                 {OutputRedirected, Console.IsOutputRedirected.ToString()},
-                {RuntimeId, RuntimeEnvironment.GetRuntimeIdentifier()},
+                {RuntimeId, RuntimeInformation.RuntimeIdentifier},
                 {ProductVersion, Product.Version},
                 {TelemetryProfile, Environment.GetEnvironmentVariable(TelemetryProfileEnvironmentVariable)},
                 {DockerContainer, _userLevelCacheWriter.RunWithCache(IsDockerContainerCacheKey, () => _dockerContainerDetector.IsDockerContainer().ToString("G") )},
diff --git a/src/Cli/dotnet/commands/dotnet-tool/install/ProjectRestorer.cs b/src/Cli/dotnet/commands/dotnet-tool/install/ProjectRestorer.cs
index 4e96594be861..6a6d3b35a1fb 100644
--- a/src/Cli/dotnet/commands/dotnet-tool/install/ProjectRestorer.cs
+++ b/src/Cli/dotnet/commands/dotnet-tool/install/ProjectRestorer.cs
@@ -6,9 +6,7 @@
 using System.Linq;
 using Microsoft.DotNet.Cli;
 using Microsoft.DotNet.Cli.Utils;
-using Microsoft.DotNet.Tools;
 using Microsoft.DotNet.ToolPackage;
-using Microsoft.DotNet.PlatformAbstractions;
 using Microsoft.Extensions.EnvironmentAbstractions;
 
 namespace Microsoft.DotNet.Tools.Tool.Install
diff --git a/src/Cli/dotnet/dotnet.csproj b/src/Cli/dotnet/dotnet.csproj
index f2bd642d40d7..fb881dbf6f1d 100644
--- a/src/Cli/dotnet/dotnet.csproj
+++ b/src/Cli/dotnet/dotnet.csproj
@@ -64,7 +64,6 @@
     <PackageReference Include="Newtonsoft.Json" Version="$(NewtonsoftJsonPackageVersion)" />
     <PackageReference Include="Microsoft.ApplicationInsights" Version="$(MicrosoftApplicationInsightsPackageVersion)" />
     <PackageReference Include="Microsoft.Build" Version="$(MicrosoftBuildPackageVersion)" />
-    <PackageReference Include="Microsoft.DotNet.PlatformAbstractions" Version="$(MicrosoftDotNetPlatformAbstractionsPackageVersion)" />
     <PackageReference Include="Microsoft.DotNet.Cli.CommandLine" Version="$(MicrosoftDotNetCliCommandLinePackageVersion)" />
     <PackageReference Include="Microsoft.NET.HostModel" Version="$(MicrosoftNETHostModelVersion)" />
     <PackageReference Include="Microsoft.TemplateEngine.Abstractions" Version="$(MicrosoftTemplateEngineAbstractionsPackageVersion)" />
diff --git a/src/Layout/redist/targets/GetRuntimeInformation.targets b/src/Layout/redist/targets/GetRuntimeInformation.targets
index 8ad7b45bce41..c0341289f9ec 100644
--- a/src/Layout/redist/targets/GetRuntimeInformation.targets
+++ b/src/Layout/redist/targets/GetRuntimeInformation.targets
@@ -5,15 +5,12 @@
     <GetCurrentRuntimeInformation>
       <Output TaskParameter="Rid" PropertyName="HostRid" />
       <Output TaskParameter="OSName" PropertyName="HostOSName" />
-      <Output TaskParameter="OSPlatform" PropertyName="HostOSPlatform" />
     </GetCurrentRuntimeInformation>
 
     <PropertyGroup>
       <IsLinux Condition = " '$(HostOSName)' != 'win' AND '$(HostOSName)' != 'osx' ">True</IsLinux>
       <OSName Condition=" '$(OSName)' == '' AND '$(IsLinux)' != 'True' ">$(HostOSName)</OSName>
-      <OSPlatform Condition=" '$(OSPlatform)' == '' AND '$(IsLinux)' != 'True' ">$(HostOSPlatform)</OSPlatform>
       <OSName Condition=" '$(OSName)' == '' AND '$(IsLinux)' == 'True' ">linux</OSName>
-      <OSPlatform Condition=" '$(OSPlatform)' == '' AND '$(IsLinux)' == 'True' ">linux</OSPlatform>
 
       <Architecture Condition=" '$(Architecture)' == '' ">x64</Architecture>
       <Rid Condition=" '$(Rid)' == '' ">$(OSName)-$(Architecture)</Rid>
diff --git a/src/Layout/toolset-tasks/CurrentPlatform.cs b/src/Layout/toolset-tasks/CurrentPlatform.cs
index 93ff09bfb0fc..17d3fcea30a0 100644
--- a/src/Layout/toolset-tasks/CurrentPlatform.cs
+++ b/src/Layout/toolset-tasks/CurrentPlatform.cs
@@ -2,10 +2,8 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 using System;
-using System.Linq;
 using System.Runtime.InteropServices;
-using Microsoft.DotNet.PlatformAbstractions;
-using RuntimeEnvironment = Microsoft.DotNet.PlatformAbstractions.RuntimeEnvironment;
+using RuntimeEnvironment = Microsoft.DotNet.Cli.Utils.RuntimeEnvironment;
 
 namespace Microsoft.DotNet.Cli.Build.Framework
 {
@@ -113,52 +111,6 @@ public static bool IsLinux
             }
         }
 
-        public static bool IsPlatform(BuildPlatform platform, string version = null)
-        {
-            return IsPlatform(platform) && (version == null || IsVersion(version));
-        }
-
-        public static bool IsAnyPlatform(params BuildPlatform[] platforms)
-        {
-            return platforms.Any(p => IsPlatform(p));
-        }
-
-        public static bool IsPlatform(BuildPlatform platform)
-        {
-            switch (platform)
-            {
-                case BuildPlatform.Windows:
-                    return IsWindows;
-                case BuildPlatform.Ubuntu:
-                    return IsUbuntu;
-                case BuildPlatform.OSX:
-                    return IsOSX;
-                case BuildPlatform.FreeBSD:
-                    return IsFreeBSD;
-                case BuildPlatform.CentOS:
-                    return IsCentOS;
-                case BuildPlatform.RHEL:
-                    return IsRHEL;
-                case BuildPlatform.Debian:
-                    return IsDebian;
-                case BuildPlatform.Fedora:
-                    return IsFedora;
-                case BuildPlatform.OpenSuse:
-                    return IsOpenSuse;
-                case BuildPlatform.Unix:
-                    return IsUnix;
-                case BuildPlatform.Linux:
-                    return IsLinux;
-                default:
-                    throw new Exception("Unrecognized Platform.");
-            }
-        }
-
-        public static bool IsVersion(string version)
-        {
-            return RuntimeEnvironment.OperatingSystemVersion.Equals(version, StringComparison.OrdinalIgnoreCase);
-        }
-
         private static BuildPlatform DetermineCurrentPlatform()
         {
             if (IsWindows)
diff --git a/src/Layout/toolset-tasks/GetCurrentRuntimeInformation.cs b/src/Layout/toolset-tasks/GetCurrentRuntimeInformation.cs
index 7506491f2f53..c9f61aac57f0 100644
--- a/src/Layout/toolset-tasks/GetCurrentRuntimeInformation.cs
+++ b/src/Layout/toolset-tasks/GetCurrentRuntimeInformation.cs
@@ -4,7 +4,7 @@
 using Microsoft.Build.Framework;
 using Microsoft.Build.Utilities;
 using Microsoft.DotNet.Cli.Build.Framework;
-using Microsoft.DotNet.PlatformAbstractions;
+using Microsoft.DotNet.Cli.Utils;
 
 namespace Microsoft.DotNet.Cli.Build
 {
@@ -16,14 +16,10 @@ public class GetCurrentRuntimeInformation : Task
         [Output]
         public string OSName { get; set; }
 
-        [Output]
-        public string OSPlatform { get; set; }
-
         public override bool Execute()
         {
             Rid = RuntimeEnvironment.GetRuntimeIdentifier();
             OSName = GetOSShortName();
-            OSPlatform = RuntimeEnvironment.OperatingSystemPlatform.ToString().ToLower();
 
             return true;
         }
diff --git a/src/Layout/toolset-tasks/toolset-tasks.csproj b/src/Layout/toolset-tasks/toolset-tasks.csproj
index ef4c4e85cbcd..9b51bae96ae7 100644
--- a/src/Layout/toolset-tasks/toolset-tasks.csproj
+++ b/src/Layout/toolset-tasks/toolset-tasks.csproj
@@ -1,13 +1,17 @@
-<Project Sdk="Microsoft.NET.Sdk" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+<Project Sdk="Microsoft.NET.Sdk" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <PropertyGroup>
     <TargetFrameworks>$(SdkTargetFramework);net472</TargetFrameworks>
     <TargetFrameworks Condition="'$(OS)' != 'Windows_NT'">$(SdkTargetFramework)</TargetFrameworks>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
   </PropertyGroup>
 
+  <ItemGroup>
+    <Compile Include="..\..\Cli\Microsoft.DotNet.Cli.Utils\RuntimeEnvironment.cs" />
+  </ItemGroup>
+
   <ItemGroup>
     <PackageReference Include="Microsoft.Build" Version="15.7.179" />
     <PackageReference Include="Microsoft.Build.Utilities.Core" Version="15.7.179" />
-    <PackageReference Include="Microsoft.DotNet.PlatformAbstractions" Version="2.0.0" />
     <PackageReference Include="Newtonsoft.Json" Version="9.0.1" />
     <PackageReference Include="NuGet.Versioning" Version="4.3.0" />
     <PackageReference Include="System.Reflection.Metadata" Version="1.4.2" />
diff --git a/src/Tasks/Microsoft.NET.Build.Tasks/FrameworkReferenceResolver.cs b/src/Tasks/Microsoft.NET.Build.Tasks/FrameworkReferenceResolver.cs
index aff4183608da..c93d596fdfd3 100644
--- a/src/Tasks/Microsoft.NET.Build.Tasks/FrameworkReferenceResolver.cs
+++ b/src/Tasks/Microsoft.NET.Build.Tasks/FrameworkReferenceResolver.cs
@@ -3,8 +3,7 @@
 
 using System;
 using System.IO;
-using Microsoft.Build.Framework;
-using Microsoft.DotNet.PlatformAbstractions;
+using System.Runtime.InteropServices;
 using Microsoft.Extensions.DependencyModel.Resolution;
 
 namespace Microsoft.NET.Build.Tasks
@@ -21,7 +20,7 @@ public static string GetDefaultReferenceAssembliesPath()
                 return referenceAssembliesPath;
             }
 
-            if (RuntimeEnvironment.OperatingSystemPlatform != Platform.Windows)
+            if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
             {
                 // There is no reference assemblies path outside of windows
                 // The environment variable can be used to specify one
diff --git a/src/Tasks/Microsoft.NET.Build.Tasks/Microsoft.NET.Build.Tasks.csproj b/src/Tasks/Microsoft.NET.Build.Tasks/Microsoft.NET.Build.Tasks.csproj
index 9a885714e13a..2f4885ce1969 100644
--- a/src/Tasks/Microsoft.NET.Build.Tasks/Microsoft.NET.Build.Tasks.csproj
+++ b/src/Tasks/Microsoft.NET.Build.Tasks/Microsoft.NET.Build.Tasks.csproj
@@ -44,8 +44,6 @@
     <PackageReference Include="Microsoft.NET.HostModel" Version="$(MicrosoftNETHostModelVersion)" />
     <PackageReference Include="NuGet.ProjectModel" Version="$(NuGetProjectModelVersion)" />
     <PackageReference Include="NuGet.Build.Tasks.Pack" Version="$(NuGetBuildTasksPackageVersion)" ExcludeAssets="All" />
-
-    <PackageReference Include="Microsoft.DotNet.PlatformAbstractions" Version="$(MicrosoftDotNetPlatformAbstractionsPackageVersion)" />
   </ItemGroup>
 
 
diff --git a/src/Tests/ArgumentForwarding.Tests/ArgumentForwarding.Tests.csproj b/src/Tests/ArgumentForwarding.Tests/ArgumentForwarding.Tests.csproj
index 10dac8acf5bc..da033cd6ba6a 100644
--- a/src/Tests/ArgumentForwarding.Tests/ArgumentForwarding.Tests.csproj
+++ b/src/Tests/ArgumentForwarding.Tests/ArgumentForwarding.Tests.csproj
@@ -11,10 +11,6 @@
     <ProjectReference Include="..\Microsoft.NET.TestFramework\Microsoft.NET.TestFramework.csproj" />
   </ItemGroup>
 
-  <ItemGroup>
-    <PackageReference Include="Microsoft.DotNet.PlatformAbstractions" Version="$(MicrosoftDotNetPlatformAbstractionsPackageVersion)" />
-  </ItemGroup>
-
   <Target Name="PrecompileScript" BeforeTargets="Build" Condition=" '$(IsCrossTargetingBuild)' != 'true' ">
     <MSBuild
       BuildInParallel="False"
diff --git a/src/Tests/EndToEnd.Tests/EndToEnd.Tests.csproj b/src/Tests/EndToEnd.Tests/EndToEnd.Tests.csproj
index 97c3e0c5bbdb..d4342a264fe5 100644
--- a/src/Tests/EndToEnd.Tests/EndToEnd.Tests.csproj
+++ b/src/Tests/EndToEnd.Tests/EndToEnd.Tests.csproj
@@ -8,8 +8,4 @@
   <ItemGroup>
     <ProjectReference Include="..\Microsoft.NET.TestFramework\Microsoft.NET.TestFramework.csproj" />
   </ItemGroup>
-
-  <ItemGroup>
-    <PackageReference Include="Microsoft.DotNet.PlatformAbstractions" Version="$(MicrosoftDotNetPlatformAbstractionsPackageVersion)" />
-  </ItemGroup>
 </Project>
diff --git a/src/Tests/Microsoft.DotNet.CommandFactory.Tests/GivenAProjectPathCommandResolver.cs b/src/Tests/Microsoft.DotNet.CommandFactory.Tests/GivenAProjectPathCommandResolver.cs
index a762a86c6e12..0c315c30cd79 100644
--- a/src/Tests/Microsoft.DotNet.CommandFactory.Tests/GivenAProjectPathCommandResolver.cs
+++ b/src/Tests/Microsoft.DotNet.CommandFactory.Tests/GivenAProjectPathCommandResolver.cs
@@ -6,8 +6,6 @@
 using FluentAssertions;
 using Microsoft.DotNet.Cli.Utils;
 using Microsoft.DotNet.CommandFactory;
-using Microsoft.DotNet.PlatformAbstractions;
-using Microsoft.DotNet.Tools.Test.Utilities;
 using Xunit;
 
 namespace Microsoft.DotNet.Tests
diff --git a/src/Tests/Microsoft.DotNet.CommandFactory.Tests/GivenAnAppBaseCommandResolver.cs b/src/Tests/Microsoft.DotNet.CommandFactory.Tests/GivenAnAppBaseCommandResolver.cs
index c26a87d39edf..74675163b658 100644
--- a/src/Tests/Microsoft.DotNet.CommandFactory.Tests/GivenAnAppBaseCommandResolver.cs
+++ b/src/Tests/Microsoft.DotNet.CommandFactory.Tests/GivenAnAppBaseCommandResolver.cs
@@ -4,8 +4,6 @@
 using System;
 using System.IO;
 using FluentAssertions;
-using Microsoft.DotNet.PlatformAbstractions;
-using Microsoft.DotNet.Tools.Test.Utilities;
 using Microsoft.DotNet.CommandFactory;
 using Xunit;
 using Microsoft.DotNet.Cli.Utils;
diff --git a/src/Tests/Microsoft.NET.Build.Tests/AppHostTests.cs b/src/Tests/Microsoft.NET.Build.Tests/AppHostTests.cs
index 5ee1745802d0..388a5f3bf8e4 100644
--- a/src/Tests/Microsoft.NET.Build.Tests/AppHostTests.cs
+++ b/src/Tests/Microsoft.NET.Build.Tests/AppHostTests.cs
@@ -2,15 +2,14 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 using System;
-using System.Collections.Generic;
 using System.Diagnostics;
 using System.IO;
 using System.Linq;
 using System.Reflection.PortableExecutable;
+using System.Runtime.InteropServices;
 using System.Text.RegularExpressions;
 using FluentAssertions;
 using Microsoft.DotNet.Cli.Utils;
-using Microsoft.DotNet.PlatformAbstractions;
 using Microsoft.NET.TestFramework;
 using Microsoft.NET.TestFramework.Assertions;
 using Microsoft.NET.TestFramework.Commands;
@@ -26,7 +25,7 @@ public AppHostTests(ITestOutputHelper log) : base(log)
         {
         }
 
-        [PlatformSpecificTheory(Platform.Windows, Platform.Linux, Platform.FreeBSD)]
+        [PlatformSpecificTheory(TestPlatforms.Windows | TestPlatforms.Linux | TestPlatforms.FreeBSD)]
         [InlineData("netcoreapp3.0")]
         public void It_builds_a_runnable_apphost_by_default(string targetFramework)
         {
@@ -65,7 +64,7 @@ public void It_builds_a_runnable_apphost_by_default(string targetFramework)
                 .HaveStdOutContaining("Hello World!");
         }
 
-        [PlatformSpecificFact(Platform.Darwin)]
+        [PlatformSpecificFact(TestPlatforms.OSX)]
         public void It_builds_a_runnable_apphost_if_opt_in_on_mac()
         {
             var targetFramework = "netcoreapp3.0";
@@ -101,7 +100,7 @@ public void It_builds_a_runnable_apphost_if_opt_in_on_mac()
         [InlineData("netcoreapp3.0")] // only on macOS
         public void It_does_not_build_with_an_apphost_by_default_before_netcoreapp_3_or_macOs(string targetFramework)
         {
-            if (targetFramework == "netcoreapp3.0" && RuntimeEnvironment.OperatingSystemPlatform != Platform.Darwin)
+            if (targetFramework == "netcoreapp3.0" && !RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
             {
                 return;
             }
diff --git a/src/Tests/Microsoft.NET.Build.Tests/GivenThatWeWantToBuildAComServerLibrary.cs b/src/Tests/Microsoft.NET.Build.Tests/GivenThatWeWantToBuildAComServerLibrary.cs
index a079b645af34..2a2c31fdd1d7 100644
--- a/src/Tests/Microsoft.NET.Build.Tests/GivenThatWeWantToBuildAComServerLibrary.cs
+++ b/src/Tests/Microsoft.NET.Build.Tests/GivenThatWeWantToBuildAComServerLibrary.cs
@@ -5,7 +5,6 @@
 using System.Linq;
 using System.Xml.Linq;
 using FluentAssertions;
-using Microsoft.DotNet.PlatformAbstractions;
 using Microsoft.NET.TestFramework;
 using Microsoft.NET.TestFramework.Assertions;
 using Microsoft.NET.TestFramework.Commands;
@@ -139,7 +138,7 @@ public void It_warns_on_self_contained_build()
                 .HaveStdOutContaining("NETSDK1128: ");
         }
 
-        [PlatformSpecificFact(Platform.Linux, Platform.Darwin, Platform.FreeBSD)]
+        [PlatformSpecificFact(TestPlatforms.Linux | TestPlatforms.OSX | TestPlatforms.FreeBSD)]
         public void It_fails_to_find_comhost_for_platforms_without_comhost()
         {
             var testAsset = _testAssetsManager
@@ -160,7 +159,7 @@ public void It_fails_to_find_comhost_for_platforms_without_comhost()
                 .HaveStdOutContaining("NETSDK1091: ");
         }
 
-        [PlatformSpecificTheory(Platform.Linux, Platform.Darwin, Platform.FreeBSD)]
+        [PlatformSpecificTheory(TestPlatforms.Linux | TestPlatforms.OSX | TestPlatforms.FreeBSD)]
         [InlineData("win-x64")]
         [InlineData("win-x86")]
         public void It_fails_to_embed_clsid_when_not_on_windows(string rid)
diff --git a/src/Tests/Microsoft.NET.Build.Tests/GivenThatWeWantToBuildASolutionWithProjRefDiffCase.cs b/src/Tests/Microsoft.NET.Build.Tests/GivenThatWeWantToBuildASolutionWithProjRefDiffCase.cs
index df82d0fdf266..847e818e7435 100644
--- a/src/Tests/Microsoft.NET.Build.Tests/GivenThatWeWantToBuildASolutionWithProjRefDiffCase.cs
+++ b/src/Tests/Microsoft.NET.Build.Tests/GivenThatWeWantToBuildASolutionWithProjRefDiffCase.cs
@@ -1,15 +1,11 @@
 // Copyright (c) .NET Foundation and contributors. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
-using System;
-using System.Collections.Generic;
 using System.IO;
-using System.Linq;
-using Microsoft.DotNet.PlatformAbstractions;
+using FluentAssertions;
 using Microsoft.NET.TestFramework;
 using Microsoft.NET.TestFramework.Assertions;
 using Microsoft.NET.TestFramework.Commands;
-using FluentAssertions;
 using Xunit;
 using Xunit.Abstractions;
 
@@ -21,7 +17,7 @@ public GivenThatWeWantToBuildASolutionWithProjRefDiffCase(ITestOutputHelper log)
         {
         }
 
-        [PlatformSpecificFact(Platform.Windows, Platform.Darwin)]
+        [PlatformSpecificFact(TestPlatforms.Windows | TestPlatforms.OSX)]
         public void ItBuildsTheSolutionSuccessfully()
         {
             const string solutionFile = "AppWithProjRefCaseDiff.sln";
diff --git a/src/Tests/Microsoft.NET.Build.Tests/GivenThatWeWantToBuildAnAppWithLibrariesAndRid.cs b/src/Tests/Microsoft.NET.Build.Tests/GivenThatWeWantToBuildAnAppWithLibrariesAndRid.cs
index 65bc93e2c0c3..b939a330a1f2 100644
--- a/src/Tests/Microsoft.NET.Build.Tests/GivenThatWeWantToBuildAnAppWithLibrariesAndRid.cs
+++ b/src/Tests/Microsoft.NET.Build.Tests/GivenThatWeWantToBuildAnAppWithLibrariesAndRid.cs
@@ -3,12 +3,12 @@
 
 using FluentAssertions;
 using Microsoft.DotNet.Cli.Utils;
-using Microsoft.DotNet.PlatformAbstractions;
 using Microsoft.NET.TestFramework;
 using Microsoft.NET.TestFramework.Assertions;
 using Microsoft.NET.TestFramework.Commands;
 using System.IO;
 using System.Linq;
+using System.Runtime.InteropServices;
 using System.Xml.Linq;
 using Xunit;
 using Xunit.Abstractions;
@@ -24,7 +24,7 @@ public GivenThatWeWantToBuildAnAppWithLibrariesAndRid(ITestOutputHelper log) : b
         [Fact]
         public void It_builds_a_RID_specific_runnable_output()
         {
-            var runtimeIdentifier = RuntimeEnvironment.GetRuntimeIdentifier();
+            var runtimeIdentifier = RuntimeInformation.RuntimeIdentifier;
             string[] msbuildArgs = new[]
             {
                 $"/p:RuntimeIdentifier={runtimeIdentifier}",
@@ -66,7 +66,7 @@ public void It_builds_a_RID_specific_runnable_output()
         [Fact]
         public void It_builds_a_framework_dependent_RID_specific_runnable_output()
         {
-            var runtimeIdentifier = RuntimeEnvironment.GetRuntimeIdentifier();
+            var runtimeIdentifier = RuntimeInformation.RuntimeIdentifier;
             var testAsset = _testAssetsManager
                 .CopyTestAsset("AppWithLibraryAndRid", "BuildFrameworkDependentRIDSpecific")
                 .WithSource();
diff --git a/src/Tests/Microsoft.NET.Build.Tests/GivenThatWeWantToCopyLocalDependencies.cs b/src/Tests/Microsoft.NET.Build.Tests/GivenThatWeWantToCopyLocalDependencies.cs
index cd5a103bea35..f04b6b873bd1 100644
--- a/src/Tests/Microsoft.NET.Build.Tests/GivenThatWeWantToCopyLocalDependencies.cs
+++ b/src/Tests/Microsoft.NET.Build.Tests/GivenThatWeWantToCopyLocalDependencies.cs
@@ -11,7 +11,6 @@
 using FluentAssertions;
 
 using Microsoft.DotNet.Cli.Utils;
-using Microsoft.DotNet.PlatformAbstractions;
 using Microsoft.NET.TestFramework;
 using Microsoft.NET.TestFramework.Assertions;
 using Microsoft.NET.TestFramework.Commands;
diff --git a/src/Tests/Microsoft.NET.Build.Tests/GivenThatWeWantToFilterSatelliteAssemblies.cs b/src/Tests/Microsoft.NET.Build.Tests/GivenThatWeWantToFilterSatelliteAssemblies.cs
index 136b822c866f..1d69bf4fce90 100644
--- a/src/Tests/Microsoft.NET.Build.Tests/GivenThatWeWantToFilterSatelliteAssemblies.cs
+++ b/src/Tests/Microsoft.NET.Build.Tests/GivenThatWeWantToFilterSatelliteAssemblies.cs
@@ -1,18 +1,17 @@
-using System;
+// Copyright (c) .NET Foundation and contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
 using System.Collections.Generic;
 using System.IO;
 using System.Runtime.InteropServices;
-using System.Text;
 using FluentAssertions;
 using Microsoft.DotNet.Cli.Utils;
-using Microsoft.DotNet.PlatformAbstractions;
 using Microsoft.NET.TestFramework;
 using Microsoft.NET.TestFramework.Assertions;
 using Microsoft.NET.TestFramework.Commands;
 using Microsoft.NET.TestFramework.ProjectConstruction;
 using Xunit;
 using Xunit.Abstractions;
-using RuntimeEnvironment = System.Runtime.InteropServices.RuntimeEnvironment;
 
 namespace Microsoft.NET.Build.Tests
 {
@@ -77,7 +76,7 @@ public void It_only_publish_selected_ResourceLanguages(string targetFramework, b
                     $"{testProject.Name}.runtimeconfig.dev.json"
                 });
 
-                if (testProject.TargetFrameworks == "netcoreapp3.0" && Microsoft.DotNet.PlatformAbstractions.RuntimeEnvironment.OperatingSystemPlatform != Platform.Darwin)
+                if (testProject.TargetFrameworks == "netcoreapp3.0" && !RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
                 {
                     expectedFiles.Add($"{testProject.Name}{Constants.ExeSuffix}");
                 }
diff --git a/src/Tests/Microsoft.NET.Build.Tests/GivenThatWeWantToUseVB.cs b/src/Tests/Microsoft.NET.Build.Tests/GivenThatWeWantToUseVB.cs
index 5f98176a434f..ab83ec68525a 100644
--- a/src/Tests/Microsoft.NET.Build.Tests/GivenThatWeWantToUseVB.cs
+++ b/src/Tests/Microsoft.NET.Build.Tests/GivenThatWeWantToUseVB.cs
@@ -13,7 +13,6 @@
 using Xunit;
 using System;
 using System.IO;
-using Microsoft.DotNet.PlatformAbstractions;
 using Microsoft.NET.TestFramework.ProjectConstruction;
 using Microsoft.Build.Utilities;
 
diff --git a/src/Tests/Microsoft.NET.Build.Tests/GivenWeWantToRequireWindowsForDesktopApps.cs b/src/Tests/Microsoft.NET.Build.Tests/GivenWeWantToRequireWindowsForDesktopApps.cs
index 0023f626648f..dd429d64ac0f 100644
--- a/src/Tests/Microsoft.NET.Build.Tests/GivenWeWantToRequireWindowsForDesktopApps.cs
+++ b/src/Tests/Microsoft.NET.Build.Tests/GivenWeWantToRequireWindowsForDesktopApps.cs
@@ -4,7 +4,6 @@
 using System;
 using System.IO;
 using System.Xml.Linq;
-using Microsoft.DotNet.PlatformAbstractions;
 using Microsoft.NET.Build.Tasks;
 using Microsoft.NET.TestFramework;
 using Microsoft.NET.TestFramework.Assertions;
@@ -39,7 +38,7 @@ public void It_builds_on_windows_with_the_windows_desktop_sdk(string uiFramework
                 .Pass();
         }
 
-        [PlatformSpecificTheory(Platform.Linux, Platform.Darwin, Platform.FreeBSD)]
+        [PlatformSpecificTheory(TestPlatforms.Linux | TestPlatforms.OSX | TestPlatforms.FreeBSD)]
         [InlineData("UseWPF")]
         [InlineData("UseWindowsForms")]
         public void It_errors_on_nonwindows_with_the_windows_desktop_sdk(string uiFrameworkProperty)
@@ -76,7 +75,7 @@ public void It_builds_on_windows_with_a_framework_reference(string desktopFramew
                 .Pass();
         }
 
-        [PlatformSpecificTheory(Platform.Linux, Platform.Darwin, Platform.FreeBSD)]
+        [PlatformSpecificTheory(TestPlatforms.Linux | TestPlatforms.OSX | TestPlatforms.FreeBSD)]
         [InlineData("Microsoft.WindowsDesktop.App")]
         [InlineData("Microsoft.WindowsDesktop.App.WindowsForms")]
         [InlineData("Microsoft.WindowsDesktop.App.WPF")]
@@ -123,7 +122,7 @@ public void It_does_not_download_desktop_targeting_packs_on_unix()
             Directory.Exists(Path.Combine(asset.Path, ProjectName, "packages")).Should().BeFalse();
         }
 
-        [PlatformSpecificFact(Platform.Linux, Platform.Darwin, Platform.FreeBSD)]
+        [PlatformSpecificFact(TestPlatforms.Linux | TestPlatforms.OSX | TestPlatforms.FreeBSD)]
         public void It_does_not_download_desktop_runtime_packs_on_unix()
         {
             const string ProjectName = "NoDownloadRuntimePackTest";
diff --git a/src/Tests/Microsoft.NET.Pack.Tests/GivenThatWeWantToPackACrossTargetedLibrary.cs b/src/Tests/Microsoft.NET.Pack.Tests/GivenThatWeWantToPackACrossTargetedLibrary.cs
index 2524c2c205db..37c95974bc2e 100644
--- a/src/Tests/Microsoft.NET.Pack.Tests/GivenThatWeWantToPackACrossTargetedLibrary.cs
+++ b/src/Tests/Microsoft.NET.Pack.Tests/GivenThatWeWantToPackACrossTargetedLibrary.cs
@@ -2,9 +2,6 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 using System.IO;
-using System.Runtime.InteropServices;
-using Microsoft.DotNet.Cli.Utils;
-using Microsoft.DotNet.PlatformAbstractions;
 using Microsoft.NET.TestFramework;
 using Microsoft.NET.TestFramework.Assertions;
 using Microsoft.NET.TestFramework.Commands;
diff --git a/src/Tests/Microsoft.NET.Pack.Tests/GivenThatWeWantToPackASimpleLibrary.cs b/src/Tests/Microsoft.NET.Pack.Tests/GivenThatWeWantToPackASimpleLibrary.cs
index d444539c0074..693b453d78c2 100644
--- a/src/Tests/Microsoft.NET.Pack.Tests/GivenThatWeWantToPackASimpleLibrary.cs
+++ b/src/Tests/Microsoft.NET.Pack.Tests/GivenThatWeWantToPackASimpleLibrary.cs
@@ -2,9 +2,6 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 using System.IO;
-using System.Runtime.InteropServices;
-using Microsoft.DotNet.Cli.Utils;
-using Microsoft.DotNet.PlatformAbstractions;
 using Microsoft.NET.TestFramework;
 using Microsoft.NET.TestFramework.Assertions;
 using Microsoft.NET.TestFramework.Commands;
diff --git a/src/Tests/Microsoft.NET.Publish.Tests/FilesCopiedToPublishDirTests.cs b/src/Tests/Microsoft.NET.Publish.Tests/FilesCopiedToPublishDirTests.cs
index a6f2f1ec515d..fe9ac0fb31e9 100644
--- a/src/Tests/Microsoft.NET.Publish.Tests/FilesCopiedToPublishDirTests.cs
+++ b/src/Tests/Microsoft.NET.Publish.Tests/FilesCopiedToPublishDirTests.cs
@@ -1,10 +1,13 @@
-using System;
+// Copyright (c) .NET Foundation and contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Runtime.InteropServices;
 using FluentAssertions;
 using Microsoft.DotNet.Cli.Utils;
-using Microsoft.DotNet.PlatformAbstractions;
 using Microsoft.NET.TestFramework;
 using Microsoft.NET.TestFramework.Assertions;
 using Microsoft.NET.TestFramework.Commands;
@@ -87,7 +90,7 @@ public void RunFilesCopiedToPublishDirTest(bool specifyRid, bool singleFile)
             }
 
             // Check for the main exe
-            if (RuntimeEnvironment.OperatingSystemPlatform != Platform.Darwin)
+            if (!RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
             {
                 string exeSuffix = specifyRid ? ".exe" : Constants.ExeSuffix;
                 items.Should().ContainSingle(i => i.RelativePath.Equals($"{testProject.Name}{exeSuffix}", StringComparison.OrdinalIgnoreCase));
diff --git a/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToExcludeAPackageFromPublish.cs b/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToExcludeAPackageFromPublish.cs
index 04ebf7572eec..81f31951bb76 100644
--- a/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToExcludeAPackageFromPublish.cs
+++ b/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToExcludeAPackageFromPublish.cs
@@ -3,8 +3,6 @@
 
 using System.IO;
 using System.Runtime.InteropServices;
-using Microsoft.DotNet.Cli.Utils;
-using Microsoft.DotNet.PlatformAbstractions;
 using Microsoft.NET.TestFramework;
 using Microsoft.NET.TestFramework.Assertions;
 using Microsoft.NET.TestFramework.Commands;
@@ -13,7 +11,6 @@
 using Xunit.Abstractions;
 using System.Collections.Generic;
 using Microsoft.NET.TestFramework.ProjectConstruction;
-using RuntimeEnvironment = Microsoft.DotNet.PlatformAbstractions.RuntimeEnvironment;
 
 namespace Microsoft.NET.Publish.Tests
 {
@@ -61,7 +58,7 @@ public void It_does_not_publish_a_PackageReference_with_PrivateAssets_All(string
                 "HelloWorld.runtimeconfig.json"
             };
 
-            if (shouldIncludeExecutable && RuntimeEnvironment.OperatingSystemPlatform != Platform.Darwin)
+            if (shouldIncludeExecutable && !RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
             {
                 expectedFiles.Add("HelloWorld" + EnvironmentInfo.ExecutableExtension);
             }
@@ -106,7 +103,7 @@ public void It_does_not_publish_a_PackageReference_with_Publish_false(string tar
                 "HelloWorld.runtimeconfig.json"
             };
 
-            if (shouldIncludeExecutable && RuntimeEnvironment.OperatingSystemPlatform != Platform.Darwin)
+            if (shouldIncludeExecutable && !RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
             {
                 expectedFiles.Add("HelloWorld" + EnvironmentInfo.ExecutableExtension);
             }
@@ -158,7 +155,7 @@ public void It_publishes_a_PackageReference_with_PrivateAssets_All_and_Publish_t
                 expectedFiles.Add("System.Runtime.Serialization.Primitives.dll");
             }
 
-            if (shouldIncludeExecutable && RuntimeEnvironment.OperatingSystemPlatform != Platform.Darwin)
+            if (shouldIncludeExecutable && !RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
             {
                 expectedFiles.Add("HelloWorld" + EnvironmentInfo.ExecutableExtension);
             }
diff --git a/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToFilterSatelliteAssemblies.cs b/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToFilterSatelliteAssemblies.cs
index 0a607f9f911f..dde5f7dd0cb2 100644
--- a/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToFilterSatelliteAssemblies.cs
+++ b/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToFilterSatelliteAssemblies.cs
@@ -5,15 +5,12 @@
 using System.IO;
 using System.Runtime.InteropServices;
 using Microsoft.DotNet.Cli.Utils;
-using Microsoft.DotNet.PlatformAbstractions;
 using Microsoft.NET.TestFramework;
 using Microsoft.NET.TestFramework.Assertions;
 using Microsoft.NET.TestFramework.Commands;
+using Microsoft.NET.TestFramework.ProjectConstruction;
 using Xunit;
-using System.Xml.Linq;
 using Xunit.Abstractions;
-using Microsoft.NET.TestFramework.ProjectConstruction;
-using RuntimeEnvironment = Microsoft.DotNet.PlatformAbstractions.RuntimeEnvironment;
 
 namespace Microsoft.NET.Publish.Tests
 {
@@ -59,7 +56,7 @@ public void It_only_publishes_selected_ResourceLanguages(string tfm)
                 $"{testProject.Name}.runtimeconfig.json"
             };
 
-            if (tfm == "netcoreapp3.0" && RuntimeEnvironment.OperatingSystemPlatform != Platform.Darwin)
+            if (tfm == "netcoreapp3.0" && !RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
             {
                 files.Add($"{testProject.Name}{Constants.ExeSuffix}");
             }
diff --git a/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToPublishAFrameworkDependentApp.cs b/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToPublishAFrameworkDependentApp.cs
index ed1af3add4d9..5c8df9cef4ba 100644
--- a/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToPublishAFrameworkDependentApp.cs
+++ b/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToPublishAFrameworkDependentApp.cs
@@ -4,10 +4,9 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
-using System.Linq;
+using System.Runtime.InteropServices;
 using FluentAssertions;
 using Microsoft.DotNet.Cli.Utils;
-using Microsoft.DotNet.PlatformAbstractions;
 using Microsoft.NET.Build.Tasks;
 using Microsoft.NET.TestFramework;
 using Microsoft.NET.TestFramework.Assertions;
@@ -37,7 +36,7 @@ public GivenThatWeWantToPublishAFrameworkDependentApp(ITestOutputHelper log) : b
         [InlineData("false", "netcoreapp3.0")]
         public void It_publishes_with_or_without_apphost(string useAppHost, string targetFramework)
         {
-            var runtimeIdentifier = RuntimeEnvironment.GetRuntimeIdentifier();
+            var runtimeIdentifier = RuntimeInformation.RuntimeIdentifier;
             var appHostName = $"{TestProjectName}{Constants.ExeSuffix}";
 
             var testAsset = _testAssetsManager
@@ -107,7 +106,7 @@ public void It_publishes_with_or_without_apphost(string useAppHost, string targe
         [Fact]
         public void It_errors_when_using_app_host_with_older_target_framework()
         {
-            var runtimeIdentifier = RuntimeEnvironment.GetRuntimeIdentifier();
+            var runtimeIdentifier = RuntimeInformation.RuntimeIdentifier;
 
             var testAsset = _testAssetsManager
                 .CopyTestAsset(TestProjectName)
diff --git a/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToPublishAHelloWorldProject.cs b/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToPublishAHelloWorldProject.cs
index fcdccebff5b0..6ecaebc1d04f 100644
--- a/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToPublishAHelloWorldProject.cs
+++ b/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToPublishAHelloWorldProject.cs
@@ -4,7 +4,6 @@
 using System.IO;
 using System.Runtime.InteropServices;
 using Microsoft.DotNet.Cli.Utils;
-using Microsoft.DotNet.PlatformAbstractions;
 using Microsoft.NET.TestFramework;
 using Microsoft.NET.TestFramework.Assertions;
 using Microsoft.NET.TestFramework.Commands;
@@ -15,7 +14,6 @@
 using System;
 using Microsoft.Extensions.DependencyModel;
 using Xunit.Abstractions;
-using RuntimeEnvironment = Microsoft.DotNet.PlatformAbstractions.RuntimeEnvironment;
 
 namespace Microsoft.NET.Publish.Tests
 {
@@ -398,8 +396,6 @@ public static void Main()
         [Fact]
         public void A_deployment_project_can_reference_the_hello_world_project()
         {
-            var rid = Microsoft.DotNet.PlatformAbstractions.RuntimeEnvironment.GetRuntimeIdentifier();
-
             var helloWorldAsset = _testAssetsManager
                 .CopyTestAsset("DeployProjectReferencingSdkProject")
                 .WithSource();
diff --git a/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToPublishAProjectWithDependencies.cs b/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToPublishAProjectWithDependencies.cs
index 65351be8b511..a74bfd79b479 100644
--- a/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToPublishAProjectWithDependencies.cs
+++ b/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToPublishAProjectWithDependencies.cs
@@ -162,7 +162,7 @@ public void It_publishes_projects_with_filter_and_rid()
         {
             string project = "SimpleDependencies";
             string targetFramework = "netcoreapp2.1";
-            var rid = Microsoft.DotNet.PlatformAbstractions.RuntimeEnvironment.GetRuntimeIdentifier();
+            var rid = RuntimeInformation.RuntimeIdentifier;
             TestAsset simpleDependenciesAsset = _testAssetsManager
                 .CopyTestAsset(project)
                 .WithSource()
diff --git a/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToPublishASelfContainedApp.cs b/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToPublishASelfContainedApp.cs
index c171b755e454..79a371a02000 100644
--- a/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToPublishASelfContainedApp.cs
+++ b/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToPublishASelfContainedApp.cs
@@ -2,7 +2,6 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 using FluentAssertions;
-using Microsoft.DotNet.PlatformAbstractions;
 using Microsoft.NET.Build.Tasks;
 using Microsoft.NET.TestFramework;
 using Microsoft.NET.TestFramework.Assertions;
@@ -10,6 +9,7 @@
 using Microsoft.NET.TestFramework.ProjectConstruction;
 using System;
 using System.IO;
+using System.Runtime.InteropServices;
 using Xunit;
 using Xunit.Abstractions;
 
@@ -45,7 +45,7 @@ public void It_errors_when_publishing_self_contained_app_without_rid()
         [Fact]
         public void It_errors_when_publishing_self_contained_without_apphost()
         {
-            var runtimeIdentifier = RuntimeEnvironment.GetRuntimeIdentifier();
+            var runtimeIdentifier = RuntimeInformation.RuntimeIdentifier;
 
             var testAsset = _testAssetsManager
                 .CopyTestAsset(TestProjectName)
@@ -68,7 +68,7 @@ public void It_errors_when_publishing_self_contained_without_apphost()
         [Fact]
         public void It_does_not_fail_publishing_a_self_twice()
         {
-            var runtimeIdentifier = RuntimeEnvironment.GetRuntimeIdentifier();
+            var runtimeIdentifier = RuntimeInformation.RuntimeIdentifier;
 
             var testAsset = _testAssetsManager
                 .CopyTestAsset(TestProjectName)
diff --git a/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToPublishASingleFileApp.cs b/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToPublishASingleFileApp.cs
index 33de944334de..3c342e76fb30 100644
--- a/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToPublishASingleFileApp.cs
+++ b/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToPublishASingleFileApp.cs
@@ -3,7 +3,6 @@
 
 using FluentAssertions;
 using Microsoft.DotNet.Cli.Utils;
-using Microsoft.DotNet.PlatformAbstractions;
 using Microsoft.NET.Build.Tasks;
 using Microsoft.NET.TestFramework;
 using Microsoft.NET.TestFramework.Assertions;
@@ -13,6 +12,7 @@
 using Xunit.Abstractions;
 using System;
 using System.IO;
+using System.Runtime.InteropServices;
 
 namespace Microsoft.NET.Publish.Tests
 {
@@ -30,7 +30,7 @@ public class GivenThatWeWantToPublishASingleFileApp : SdkTest
         private const string ReadyToRunWithSymbols = "/p:PublishReadyToRunEmitSymbols=true";
         private const string UseAppHost = "/p:UseAppHost=true";
 
-        private readonly string RuntimeIdentifier = $"/p:RuntimeIdentifier={RuntimeEnvironment.GetRuntimeIdentifier()}";
+        private readonly string RuntimeIdentifier = $"/p:RuntimeIdentifier={RuntimeInformation.RuntimeIdentifier}";
         private readonly string SingleFile = $"{TestProjectName}{Constants.ExeSuffix}";
         private readonly string PdbFile = $"{TestProjectName}.pdb";
         private readonly string NiPdbFile = $"{TestProjectName}.ni.pdb";
@@ -69,7 +69,7 @@ private PublishCommand GetPublishCommand()
         private DirectoryInfo GetPublishDirectory(PublishCommand publishCommand)
         {
             return publishCommand.GetOutputDirectory(targetFramework: "netcoreapp3.0",
-                                                     runtimeIdentifier: RuntimeEnvironment.GetRuntimeIdentifier());
+                                                     runtimeIdentifier: RuntimeInformation.RuntimeIdentifier);
         }
 
         [Fact]
diff --git a/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToPublishAWebApp.cs b/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToPublishAWebApp.cs
index 34b91bff9fac..e3c7cb846cc5 100644
--- a/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToPublishAWebApp.cs
+++ b/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToPublishAWebApp.cs
@@ -3,7 +3,6 @@
 
 using FluentAssertions;
 using Microsoft.DotNet.Cli.Utils;
-using Microsoft.DotNet.PlatformAbstractions;
 using Microsoft.NET.TestFramework;
 using Microsoft.NET.TestFramework.Assertions;
 using Microsoft.NET.TestFramework.Commands;
diff --git a/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToPublishAnAppWithLibrariesAndRid.cs b/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToPublishAnAppWithLibrariesAndRid.cs
index 099cc26fdb8e..a796078805a3 100644
--- a/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToPublishAnAppWithLibrariesAndRid.cs
+++ b/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToPublishAnAppWithLibrariesAndRid.cs
@@ -1,15 +1,14 @@
 // Copyright (c) .NET Foundation and contributors. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
+using System.Collections.Generic;
+using System.IO;
+using System.Runtime.InteropServices;
 using FluentAssertions;
 using Microsoft.DotNet.Cli.Utils;
-using Microsoft.DotNet.PlatformAbstractions;
 using Microsoft.NET.TestFramework;
 using Microsoft.NET.TestFramework.Assertions;
 using Microsoft.NET.TestFramework.Commands;
-using System.Collections.Generic;
-using System.IO;
-using System.Runtime.InteropServices;
 using Xunit;
 using Xunit.Abstractions;
 
@@ -90,7 +89,7 @@ public void It_publishes_a_framework_dependent_RID_specific_runnable_output()
 
         private void PublishAppWithLibraryAndRid(bool selfContained, out DirectoryInfo publishDirectory, out string runtimeIdentifier)
         {
-            runtimeIdentifier = DotNet.PlatformAbstractions.RuntimeEnvironment.GetRuntimeIdentifier();
+            runtimeIdentifier = RuntimeInformation.RuntimeIdentifier;
             var testAsset = _testAssetsManager
                 .CopyTestAsset("AppWithLibraryAndRid", $"PublishAppWithLibraryAndRid{selfContained}")
                 .WithSource();
diff --git a/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToPublishAnUnpublishableProject.cs b/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToPublishAnUnpublishableProject.cs
index 0f1675873010..7da4a0cc9eb1 100644
--- a/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToPublishAnUnpublishableProject.cs
+++ b/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToPublishAnUnpublishableProject.cs
@@ -1,14 +1,9 @@
 // Copyright (c) .NET Foundation and contributors. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
-using System.IO;
-using System.Runtime.InteropServices;
-using Microsoft.DotNet.Cli.Utils;
-using Microsoft.DotNet.PlatformAbstractions;
 using Microsoft.NET.TestFramework;
 using Microsoft.NET.TestFramework.Assertions;
 using Microsoft.NET.TestFramework.Commands;
-using Microsoft.NET.TestFramework.ProjectConstruction;
 using Xunit;
 using Xunit.Abstractions;
 
@@ -37,4 +32,4 @@ public void It_does_not_publish_to_the_publish_folder()
             publishDirectory.Should().NotExist();
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToPublishReadyToRun.cs b/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToPublishReadyToRun.cs
index 627818c7b9a5..a09baeb3db68 100644
--- a/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToPublishReadyToRun.cs
+++ b/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToPublishReadyToRun.cs
@@ -173,7 +173,7 @@ public void It_warns_when_targetting_netcoreapp_2_x()
             var publishCommand = new PublishCommand(Log, Path.Combine(testAsset.TestRoot, testProject.Name));
 
             publishCommand.Execute($"/p:PublishReadyToRun=true",
-                                   $"/p:RuntimeIdentifier={DotNet.PlatformAbstractions.RuntimeEnvironment.GetRuntimeIdentifier()}")
+                                   $"/p:RuntimeIdentifier={RuntimeInformation.RuntimeIdentifier}")
                 .Should()
                 .Pass()
                 .And
diff --git a/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToRunILLink.cs b/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToRunILLink.cs
index d4a2a1000ff8..04ef0564eac5 100644
--- a/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToRunILLink.cs
+++ b/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToRunILLink.cs
@@ -1,3 +1,6 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
 using System;
 using System.IO;
 using System.Linq;
@@ -5,7 +8,6 @@
 using System.Reflection.Metadata;
 using System.Reflection.PortableExecutable;
 using FluentAssertions;
-using Microsoft.DotNet.PlatformAbstractions;
 using Microsoft.Extensions.DependencyModel;
 using Microsoft.NET.Build.Tasks;
 using Microsoft.NET.TestFramework;
diff --git a/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToStoreAProjectWithDependencies.cs b/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToStoreAProjectWithDependencies.cs
index 0b2137897fa7..0c327bec19fb 100644
--- a/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToStoreAProjectWithDependencies.cs
+++ b/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToStoreAProjectWithDependencies.cs
@@ -31,7 +31,7 @@ public class GivenThatWeWantToStoreAProjectWithDependencies : SdkTest
 
         static GivenThatWeWantToStoreAProjectWithDependencies()
         {
-            var rid = Microsoft.DotNet.PlatformAbstractions.RuntimeEnvironment.GetRuntimeIdentifier();
+            var rid = RuntimeInformation.RuntimeIdentifier;
             if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
             {
                 _testArch = rid.Substring(rid.LastIndexOf("-") + 1);
diff --git a/src/Tests/Microsoft.NET.Publish.Tests/PublishItemsOutputGroupTests.cs b/src/Tests/Microsoft.NET.Publish.Tests/PublishItemsOutputGroupTests.cs
index 87c67d4cc428..e68df44a9640 100644
--- a/src/Tests/Microsoft.NET.Publish.Tests/PublishItemsOutputGroupTests.cs
+++ b/src/Tests/Microsoft.NET.Publish.Tests/PublishItemsOutputGroupTests.cs
@@ -1,10 +1,13 @@
-using System;
+// Copyright (c) .NET Foundation and contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Runtime.InteropServices;
 using FluentAssertions;
 using Microsoft.DotNet.Cli.Utils;
-using Microsoft.DotNet.PlatformAbstractions;
 using Microsoft.NET.TestFramework;
 using Microsoft.NET.TestFramework.Assertions;
 using Microsoft.NET.TestFramework.Commands;
@@ -68,7 +71,7 @@ public void RunPublishItemsOutputGroupTest(bool specifyRid, bool singleFile)
                 Log.WriteLine("    '{0}': TargetPath = '{1}', IsKeyOutput = '{2}'", item.Identity, item.TargetPath, item.IsKeyOutput);
             }
 
-            if (RuntimeEnvironment.OperatingSystemPlatform != Platform.Darwin)
+            if (!RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
             {
                 // Check that there's only one key item, and it's the exe
                 string exeSuffix = specifyRid ? ".exe" : Constants.ExeSuffix;
diff --git a/src/Tests/Microsoft.NET.Publish.Tests/PublishWebApp.cs b/src/Tests/Microsoft.NET.Publish.Tests/PublishWebApp.cs
index 7f406f3fffb0..3826c2352561 100644
--- a/src/Tests/Microsoft.NET.Publish.Tests/PublishWebApp.cs
+++ b/src/Tests/Microsoft.NET.Publish.Tests/PublishWebApp.cs
@@ -1,17 +1,14 @@
-using System.IO;
+// Copyright (c) .NET Foundation and contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System.IO;
+using System.Xml.Linq;
 using FluentAssertions;
-using System.Runtime.InteropServices;
-using Microsoft.DotNet.Cli.Utils;
-using Microsoft.DotNet.PlatformAbstractions;
 using Microsoft.NET.TestFramework;
 using Microsoft.NET.TestFramework.Assertions;
 using Microsoft.NET.TestFramework.Commands;
 using Microsoft.NET.TestFramework.ProjectConstruction;
 using Xunit;
-using System.Xml.Linq;
-using System.Runtime.CompilerServices;
-using System;
-using Microsoft.Extensions.DependencyModel;
 using Xunit.Abstractions;
 
 namespace Microsoft.NET.Publish.Tests
@@ -75,7 +72,6 @@ public void It_publishes_and_runs_self_contained_web_app()
                 .Pass()
                 .And
                 .HaveStdOutContaining("Hello World");
-
         }
     }
 }
diff --git a/src/Tests/Microsoft.NET.Publish.Tests/PublishWpfApp.cs b/src/Tests/Microsoft.NET.Publish.Tests/PublishWpfApp.cs
index 9b0c5b3c1e2b..fa8bf4ee719c 100644
--- a/src/Tests/Microsoft.NET.Publish.Tests/PublishWpfApp.cs
+++ b/src/Tests/Microsoft.NET.Publish.Tests/PublishWpfApp.cs
@@ -1,19 +1,14 @@
-using System.IO;
+// Copyright (c) .NET Foundation and contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System.IO;
+using System.Linq;
+using System.Xml.Linq;
 using FluentAssertions;
-using System.Runtime.InteropServices;
-using Microsoft.DotNet.Cli.Utils;
-using Microsoft.DotNet.PlatformAbstractions;
 using Microsoft.NET.TestFramework;
 using Microsoft.NET.TestFramework.Assertions;
 using Microsoft.NET.TestFramework.Commands;
-using Microsoft.NET.TestFramework.ProjectConstruction;
-using Xunit;
-using System.Xml.Linq;
-using System.Runtime.CompilerServices;
-using System;
-using Microsoft.Extensions.DependencyModel;
 using Xunit.Abstractions;
-using System.Linq;
 
 namespace Microsoft.NET.Publish.Tests
 {
@@ -77,8 +72,6 @@ public void It_publishes_and_runs_self_contained_wpf_app()
                 .Execute();
 
             result.ExitCode.Should().Be(42);
-
-
         }
     }
 }
diff --git a/src/Tests/Microsoft.NET.TestFramework/AssertionHelper.cs b/src/Tests/Microsoft.NET.TestFramework/AssertionHelper.cs
index 4fdda52da846..bf66b29cec74 100644
--- a/src/Tests/Microsoft.NET.TestFramework/AssertionHelper.cs
+++ b/src/Tests/Microsoft.NET.TestFramework/AssertionHelper.cs
@@ -2,8 +2,8 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 using System.Linq;
+using System.Runtime.InteropServices;
 using Microsoft.DotNet.Cli.Utils;
-using Microsoft.DotNet.PlatformAbstractions;
 
 public static class AssertionHelper
 {
@@ -11,7 +11,7 @@ public static string[] AppendApphostOnNonMacOS(string ProjectName, string[] expe
     {
         string apphost = $"{ProjectName}{Constants.ExeSuffix}";
         // No UseApphost is false by default on macOS
-        return RuntimeEnvironment.OperatingSystemPlatform != Platform.Darwin
+        return !RuntimeInformation.IsOSPlatform (OSPlatform.OSX)
             ? expectedFiles.Append(apphost).ToArray()
             : expectedFiles;
     }
diff --git a/src/Tests/Microsoft.NET.TestFramework/Attributes/CoreMSBuildAndWindowsOnlyFactAttribute.cs b/src/Tests/Microsoft.NET.TestFramework/Attributes/CoreMSBuildAndWindowsOnlyFactAttribute.cs
index 1cb002397955..e9cd9ede7a89 100644
--- a/src/Tests/Microsoft.NET.TestFramework/Attributes/CoreMSBuildAndWindowsOnlyFactAttribute.cs
+++ b/src/Tests/Microsoft.NET.TestFramework/Attributes/CoreMSBuildAndWindowsOnlyFactAttribute.cs
@@ -1,8 +1,7 @@
 // Copyright (c) .NET Foundation and contributors. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
-using System;
-using Microsoft.DotNet.PlatformAbstractions;
+using System.Runtime.InteropServices;
 using Xunit;
 
 namespace Microsoft.NET.TestFramework
@@ -11,7 +10,7 @@ public class CoreMSBuildAndWindowsOnlyFactAttribute : FactAttribute
     {
         public CoreMSBuildAndWindowsOnlyFactAttribute()
         {
-            if (TestContext.Current.ToolsetUnderTest.ShouldUseFullFrameworkMSBuild || RuntimeEnvironment.OperatingSystemPlatform != Platform.Windows)
+            if (TestContext.Current.ToolsetUnderTest.ShouldUseFullFrameworkMSBuild || !RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
             {
                 this.Skip = "This test requires Core MSBuild and Windows to run";
             }
diff --git a/src/Tests/Microsoft.NET.TestFramework/Attributes/CoreMSBuildAndWindowsOnlyTheoryAttribute.cs b/src/Tests/Microsoft.NET.TestFramework/Attributes/CoreMSBuildAndWindowsOnlyTheoryAttribute.cs
index 66e608b3cbdc..b8aad42dbde6 100644
--- a/src/Tests/Microsoft.NET.TestFramework/Attributes/CoreMSBuildAndWindowsOnlyTheoryAttribute.cs
+++ b/src/Tests/Microsoft.NET.TestFramework/Attributes/CoreMSBuildAndWindowsOnlyTheoryAttribute.cs
@@ -1,8 +1,7 @@
 // Copyright (c) .NET Foundation and contributors. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
-using System;
-using Microsoft.DotNet.PlatformAbstractions;
+using System.Runtime.InteropServices;
 using Xunit;
 
 namespace Microsoft.NET.TestFramework
@@ -11,7 +10,7 @@ public class CoreMSBuildAndWindowsOnlyTheoryAttribute : TheoryAttribute
     {
         public CoreMSBuildAndWindowsOnlyTheoryAttribute()
         {
-            if (TestContext.Current.ToolsetUnderTest.ShouldUseFullFrameworkMSBuild || RuntimeEnvironment.OperatingSystemPlatform != Platform.Windows)
+            if (TestContext.Current.ToolsetUnderTest.ShouldUseFullFrameworkMSBuild || !RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
             {
                 this.Skip = "This test requires Core MSBuild and Windows to run";
             }
diff --git a/src/Tests/Microsoft.NET.TestFramework/Attributes/CoreMSBuildOnlyFactAttribute.cs b/src/Tests/Microsoft.NET.TestFramework/Attributes/CoreMSBuildOnlyFactAttribute.cs
index 087a9dadd49b..f1e9ffc68c6b 100644
--- a/src/Tests/Microsoft.NET.TestFramework/Attributes/CoreMSBuildOnlyFactAttribute.cs
+++ b/src/Tests/Microsoft.NET.TestFramework/Attributes/CoreMSBuildOnlyFactAttribute.cs
@@ -1,8 +1,6 @@
 // Copyright (c) .NET Foundation and contributors. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
-using System;
-using Microsoft.DotNet.PlatformAbstractions;
 using Xunit;
 
 namespace Microsoft.NET.TestFramework
diff --git a/src/Tests/Microsoft.NET.TestFramework/Attributes/CoreMSBuildOnlyTheoryAttribute.cs b/src/Tests/Microsoft.NET.TestFramework/Attributes/CoreMSBuildOnlyTheoryAttribute.cs
index 329ff3a9a387..6da45e83764e 100644
--- a/src/Tests/Microsoft.NET.TestFramework/Attributes/CoreMSBuildOnlyTheoryAttribute.cs
+++ b/src/Tests/Microsoft.NET.TestFramework/Attributes/CoreMSBuildOnlyTheoryAttribute.cs
@@ -2,7 +2,6 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 using System;
-using Microsoft.DotNet.PlatformAbstractions;
 using Xunit;
 
 namespace Microsoft.NET.TestFramework
diff --git a/src/Tests/Microsoft.NET.TestFramework/Attributes/PlatformSpecificFact.cs b/src/Tests/Microsoft.NET.TestFramework/Attributes/PlatformSpecificFact.cs
index 78e285d268dd..3c4434b1aa60 100644
--- a/src/Tests/Microsoft.NET.TestFramework/Attributes/PlatformSpecificFact.cs
+++ b/src/Tests/Microsoft.NET.TestFramework/Attributes/PlatformSpecificFact.cs
@@ -1,20 +1,25 @@
 // Copyright (c) .NET Foundation and contributors. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
-using System.Linq;
-using Microsoft.DotNet.PlatformAbstractions;
+using System.Runtime.InteropServices;
 using Xunit;
 
 namespace Microsoft.NET.TestFramework
 {
     public class PlatformSpecificFact : FactAttribute
     {
-        public PlatformSpecificFact(params Platform[] platforms)
+        public PlatformSpecificFact(TestPlatforms platforms)
         {
-            if (!platforms.Contains(RuntimeEnvironment.OperatingSystemPlatform))
+            if (ShouldSkip(platforms))
             {
                 this.Skip = "This test is not supported on this platform.";
             }
         }
+
+        internal static bool ShouldSkip(TestPlatforms platforms) =>
+            (RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && !platforms.HasFlag(TestPlatforms.Windows))
+                || (RuntimeInformation.IsOSPlatform(OSPlatform.Linux) && !platforms.HasFlag(TestPlatforms.Linux))
+                || (RuntimeInformation.IsOSPlatform(OSPlatform.OSX) && !platforms.HasFlag(TestPlatforms.OSX))
+                || (RuntimeInformation.IsOSPlatform(OSPlatform.Create("FREEBSD")) && !platforms.HasFlag(TestPlatforms.FreeBSD));
     }
 }
diff --git a/src/Tests/Microsoft.NET.TestFramework/Attributes/PlatformSpecificTheory.cs b/src/Tests/Microsoft.NET.TestFramework/Attributes/PlatformSpecificTheory.cs
index 32e3ec95cf3b..9b38ba24b9e5 100644
--- a/src/Tests/Microsoft.NET.TestFramework/Attributes/PlatformSpecificTheory.cs
+++ b/src/Tests/Microsoft.NET.TestFramework/Attributes/PlatformSpecificTheory.cs
@@ -1,17 +1,15 @@
 // Copyright (c) .NET Foundation and contributors. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
-using System.Linq;
-using Microsoft.DotNet.PlatformAbstractions;
 using Xunit;
 
 namespace Microsoft.NET.TestFramework
 {
     public class PlatformSpecificTheory : TheoryAttribute
     {
-        public PlatformSpecificTheory(params Platform[] platforms)
+        public PlatformSpecificTheory(TestPlatforms platforms)
         {
-            if (!platforms.Contains(RuntimeEnvironment.OperatingSystemPlatform))
+            if (PlatformSpecificFact.ShouldSkip(platforms))
             {
                 this.Skip = "This test is not supported on this platform.";
             }
diff --git a/src/Tests/Microsoft.NET.TestFramework/Attributes/UnixOnlyFactAttribute.cs b/src/Tests/Microsoft.NET.TestFramework/Attributes/UnixOnlyFactAttribute.cs
index ed96718da290..3dbeb6d58e58 100644
--- a/src/Tests/Microsoft.NET.TestFramework/Attributes/UnixOnlyFactAttribute.cs
+++ b/src/Tests/Microsoft.NET.TestFramework/Attributes/UnixOnlyFactAttribute.cs
@@ -1,7 +1,7 @@
 // Copyright (c) .NET Foundation and contributors. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
-using Microsoft.DotNet.PlatformAbstractions;
+using System.Runtime.InteropServices;
 using Xunit;
 
 namespace Microsoft.NET.TestFramework
@@ -10,7 +10,7 @@ public class UnixOnlyFactAttribute : FactAttribute
     {
         public UnixOnlyFactAttribute()
         {
-            if (RuntimeEnvironment.OperatingSystemPlatform == Platform.Windows)
+            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
             {
                 this.Skip = "This test requires Unix to run";
             }
diff --git a/src/Tests/Microsoft.NET.TestFramework/Attributes/UnixOnlyTheoryAttribute.cs b/src/Tests/Microsoft.NET.TestFramework/Attributes/UnixOnlyTheoryAttribute.cs
index baa8847381ac..1ab00323dcc3 100644
--- a/src/Tests/Microsoft.NET.TestFramework/Attributes/UnixOnlyTheoryAttribute.cs
+++ b/src/Tests/Microsoft.NET.TestFramework/Attributes/UnixOnlyTheoryAttribute.cs
@@ -1,8 +1,8 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
+// Copyright (c) .NET Foundation and contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
 using Xunit;
-using Microsoft.DotNet.PlatformAbstractions;
+using System.Runtime.InteropServices;
 
 namespace Microsoft.NET.TestFramework
 {
@@ -10,7 +10,7 @@ public class UnixOnlyTheoryAttribute : TheoryAttribute
     {
         public UnixOnlyTheoryAttribute()
         {
-            if (RuntimeEnvironment.OperatingSystemPlatform == Platform.Windows)
+            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
             {
                 this.Skip = "This test requires Unix to run";
             }
diff --git a/src/Tests/Microsoft.NET.TestFramework/Attributes/WindowsOnlyFactAttribute.cs b/src/Tests/Microsoft.NET.TestFramework/Attributes/WindowsOnlyFactAttribute.cs
index c017b43652c1..389c20341cf1 100644
--- a/src/Tests/Microsoft.NET.TestFramework/Attributes/WindowsOnlyFactAttribute.cs
+++ b/src/Tests/Microsoft.NET.TestFramework/Attributes/WindowsOnlyFactAttribute.cs
@@ -1,7 +1,7 @@
 // Copyright (c) .NET Foundation and contributors. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
-using Microsoft.DotNet.PlatformAbstractions;
+using System.Runtime.InteropServices;
 using Xunit;
 
 namespace Microsoft.NET.TestFramework
@@ -10,7 +10,7 @@ public class WindowsOnlyFactAttribute : FactAttribute
     {
         public WindowsOnlyFactAttribute()
         {
-            if (RuntimeEnvironment.OperatingSystemPlatform != Platform.Windows)
+            if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
             {
                 this.Skip = "This test requires Windows to run";
             }
diff --git a/src/Tests/Microsoft.NET.TestFramework/Attributes/WindowsOnlyTheoryAttribute.cs b/src/Tests/Microsoft.NET.TestFramework/Attributes/WindowsOnlyTheoryAttribute.cs
index 288f708b6a0c..3d790bc54399 100644
--- a/src/Tests/Microsoft.NET.TestFramework/Attributes/WindowsOnlyTheoryAttribute.cs
+++ b/src/Tests/Microsoft.NET.TestFramework/Attributes/WindowsOnlyTheoryAttribute.cs
@@ -1,7 +1,7 @@
 // Copyright (c) .NET Foundation and contributors. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
-using Microsoft.DotNet.PlatformAbstractions;
+using System.Runtime.InteropServices;
 using Xunit;
 
 namespace Microsoft.NET.TestFramework
@@ -10,7 +10,7 @@ public class WindowsOnlyTheoryAttribute : TheoryAttribute
     {
         public WindowsOnlyTheoryAttribute()
         {
-            if (RuntimeEnvironment.OperatingSystemPlatform != Platform.Windows)
+            if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
             {
                 this.Skip = "This test requires Windows to run";
             }
diff --git a/src/Tests/Microsoft.NET.TestFramework/Commands/ComposeStoreCommand.cs b/src/Tests/Microsoft.NET.TestFramework/Commands/ComposeStoreCommand.cs
index e683379c0abc..e2fc5aa528bf 100644
--- a/src/Tests/Microsoft.NET.TestFramework/Commands/ComposeStoreCommand.cs
+++ b/src/Tests/Microsoft.NET.TestFramework/Commands/ComposeStoreCommand.cs
@@ -2,9 +2,7 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 using Microsoft.DotNet.Cli.Utils;
-using Microsoft.DotNet.PlatformAbstractions;
 using System.IO;
-using System.Linq;
 using Xunit.Abstractions;
 
 namespace Microsoft.NET.TestFramework.Commands
@@ -18,8 +16,6 @@ public ComposeStoreCommand(ITestOutputHelper log, string projectPath, string rel
         {
         }
 
-       
-
         public override DirectoryInfo GetOutputDirectory(string targetFramework = "netcoreapp1.0", string configuration = "Debug", string runtimeIdentifier = "")
         {
             string output = Path.Combine(ProjectRootPath, "bin", BuildRelativeOutputPath(targetFramework, configuration, runtimeIdentifier));
diff --git a/src/Tests/Microsoft.NET.TestFramework/Commands/PublishCommand.cs b/src/Tests/Microsoft.NET.TestFramework/Commands/PublishCommand.cs
index ec3efd671212..20c09f520e6e 100644
--- a/src/Tests/Microsoft.NET.TestFramework/Commands/PublishCommand.cs
+++ b/src/Tests/Microsoft.NET.TestFramework/Commands/PublishCommand.cs
@@ -1,12 +1,7 @@
 // Copyright (c) .NET Foundation and contributors. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
-using System;
 using System.IO;
-using System.Linq;
-using System.Runtime.InteropServices;
-using Microsoft.DotNet.Cli.Utils;
-using Microsoft.DotNet.PlatformAbstractions;
 using Xunit.Abstractions;
 
 namespace Microsoft.NET.TestFramework.Commands
diff --git a/src/Tests/Microsoft.NET.TestFramework/Commands/SdkCommandSpec.cs b/src/Tests/Microsoft.NET.TestFramework/Commands/SdkCommandSpec.cs
index 173e400bae9e..418decf81908 100644
--- a/src/Tests/Microsoft.NET.TestFramework/Commands/SdkCommandSpec.cs
+++ b/src/Tests/Microsoft.NET.TestFramework/Commands/SdkCommandSpec.cs
@@ -1,10 +1,9 @@
-using System;
+// Copyright (c) .NET Foundation and contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
 using System.Collections.Generic;
 using System.Diagnostics;
-using System.IO;
-using System.Text;
 using Microsoft.DotNet.Cli.Utils;
-using Microsoft.DotNet.PlatformAbstractions;
 
 namespace Microsoft.NET.TestFramework.Commands
 {
@@ -59,6 +58,4 @@ public ProcessStartInfo ToProcessStartInfo()
             return ret;
         }
     }
-
-
 }
diff --git a/src/Tests/Microsoft.NET.TestFramework/EnvironmentInfo.cs b/src/Tests/Microsoft.NET.TestFramework/EnvironmentInfo.cs
index 3db6b63c4207..689eba5765cf 100644
--- a/src/Tests/Microsoft.NET.TestFramework/EnvironmentInfo.cs
+++ b/src/Tests/Microsoft.NET.TestFramework/EnvironmentInfo.cs
@@ -2,9 +2,7 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 using System;
-using System.IO;
 using System.Runtime.InteropServices;
-using Microsoft.DotNet.PlatformAbstractions;
 using NuGet.Frameworks;
 
 namespace Microsoft.NET.TestFramework
@@ -21,7 +19,7 @@ public static string ExecutableExtension
 
         public static string GetCompatibleRid(string targetFramework = null)
         {
-            string rid = DotNet.PlatformAbstractions.RuntimeEnvironment.GetRuntimeIdentifier();
+            string rid = DotNet.Cli.Utils.RuntimeEnvironment.GetRuntimeIdentifier();
 
             if (targetFramework == null)
             {
@@ -33,9 +31,8 @@ public static string GetCompatibleRid(string targetFramework = null)
                 if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
                 {
                     Version osVersion;
-                    if (Version.TryParse(DotNet.PlatformAbstractions.RuntimeEnvironment.OperatingSystemVersion, out osVersion))
+                    if (Version.TryParse(DotNet.Cli.Utils.RuntimeEnvironment.OperatingSystemVersion, out osVersion))
                     {
-
                         if (osVersion > new Version(10, 11))
                         {
                             //  netcoreapp1.0 only supports osx.10.10 and osx.10.11
@@ -59,7 +56,7 @@ public static string GetCompatibleRid(string targetFramework = null)
         public static bool SupportsTargetFramework(string targetFramework)
         {
             var nugetFramework = NuGetFramework.Parse(targetFramework);
-            string currentRid = DotNet.PlatformAbstractions.RuntimeEnvironment.GetRuntimeIdentifier();
+            string currentRid = DotNet.Cli.Utils.RuntimeEnvironment.GetRuntimeIdentifier();
 
             string ridOS = currentRid.Split('.')[0];
             if (ridOS.Equals("alpine", StringComparison.OrdinalIgnoreCase))
diff --git a/src/Tests/Microsoft.NET.TestFramework/LinuxOnlyFactAttribute.cs b/src/Tests/Microsoft.NET.TestFramework/LinuxOnlyFactAttribute.cs
index 3dc23715c38d..4187112049af 100644
--- a/src/Tests/Microsoft.NET.TestFramework/LinuxOnlyFactAttribute.cs
+++ b/src/Tests/Microsoft.NET.TestFramework/LinuxOnlyFactAttribute.cs
@@ -1,7 +1,7 @@
 // Copyright (c) .NET Foundation and contributors. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
-using Microsoft.DotNet.PlatformAbstractions;
+using System.Runtime.InteropServices;
 using Xunit;
 
 namespace Microsoft.NET.TestFramework
@@ -10,7 +10,7 @@ public class LinuxOnlyFactAttribute : FactAttribute
     {
         public LinuxOnlyFactAttribute()
         {
-            if (RuntimeEnvironment.OperatingSystemPlatform != Platform.Linux)
+            if (!RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
             {
                 this.Skip = "This test requires linux to run";
             }
diff --git a/src/Tests/Microsoft.NET.TestFramework/MacOsOnlyFactAttribute.cs b/src/Tests/Microsoft.NET.TestFramework/MacOsOnlyFactAttribute.cs
index 85023885b165..06c2313f784e 100644
--- a/src/Tests/Microsoft.NET.TestFramework/MacOsOnlyFactAttribute.cs
+++ b/src/Tests/Microsoft.NET.TestFramework/MacOsOnlyFactAttribute.cs
@@ -1,7 +1,7 @@
 // Copyright (c) .NET Foundation and contributors. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
-using Microsoft.DotNet.PlatformAbstractions;
+using System.Runtime.InteropServices;
 using Xunit;
 
 namespace Microsoft.NET.TestFramework
@@ -10,7 +10,7 @@ public class MacOsOnlyFactAttribute : FactAttribute
     {
         public MacOsOnlyFactAttribute()
         {
-            if (RuntimeEnvironment.OperatingSystemPlatform != Platform.Darwin)
+            if (!RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
             {
                 this.Skip = "This test requires macos to run";
             }
diff --git a/src/Tests/Microsoft.NET.TestFramework/Microsoft.NET.TestFramework.csproj b/src/Tests/Microsoft.NET.TestFramework/Microsoft.NET.TestFramework.csproj
index 0b0ea686b969..e41ecea7da72 100644
--- a/src/Tests/Microsoft.NET.TestFramework/Microsoft.NET.TestFramework.csproj
+++ b/src/Tests/Microsoft.NET.TestFramework/Microsoft.NET.TestFramework.csproj
@@ -21,6 +21,7 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <PackageReference Include="Microsoft.DotNet.XUnitExtensions" Version="$(MicrosoftDotNetXUnitExtensionsVersion)" />
     <PackageReference Include="FluentAssertions" Version="$(FluentAssertionsVersion)" />
     <PackageReference Include="Newtonsoft.Json" Version="$(NewtonsoftJsonVersion)" />
     <PackageReference Include="xunit" Version="$(XUnitVersion)" />
diff --git a/src/Tests/Microsoft.NET.ToolPack.Tests/GivenThatWeWantToPackAToolProject.cs b/src/Tests/Microsoft.NET.ToolPack.Tests/GivenThatWeWantToPackAToolProject.cs
index 3fa883227987..5d6ead980632 100644
--- a/src/Tests/Microsoft.NET.ToolPack.Tests/GivenThatWeWantToPackAToolProject.cs
+++ b/src/Tests/Microsoft.NET.ToolPack.Tests/GivenThatWeWantToPackAToolProject.cs
@@ -15,8 +15,6 @@
 using System.Runtime.CompilerServices;
 using System;
 using System.Runtime.InteropServices;
-using Microsoft.DotNet.PlatformAbstractions;
-using RuntimeEnvironment = Microsoft.DotNet.PlatformAbstractions.RuntimeEnvironment;
 
 namespace Microsoft.NET.ToolPack.Tests
 {
@@ -154,7 +152,7 @@ public void It_does_not_contain_apphost_exe(bool multiTarget)
                "RunCommand",
                GetValuesCommand.ValueType.Property);
 
-            if (RuntimeEnvironment.OperatingSystemPlatform != Platform.Darwin)
+            if (!RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
             {
                 getValuesCommand.Execute();
                 string runCommandPath = getValuesCommand.GetValues().Single();
diff --git a/src/Tests/dotnet-publish.Tests/GivenDotnetPublishPublishesProjects.cs b/src/Tests/dotnet-publish.Tests/GivenDotnetPublishPublishesProjects.cs
index 54cf73fd10d1..73820143cf7c 100644
--- a/src/Tests/dotnet-publish.Tests/GivenDotnetPublishPublishesProjects.cs
+++ b/src/Tests/dotnet-publish.Tests/GivenDotnetPublishPublishesProjects.cs
@@ -3,19 +3,15 @@
 
 using System;
 using System.IO;
-using System.Diagnostics;
-using System.Runtime.InteropServices;
+using System.Runtime.CompilerServices;
 using FluentAssertions;
 using Microsoft.DotNet.Cli.Utils;
-using Microsoft.DotNet.PlatformAbstractions;
-using Microsoft.DotNet.Tools.Test.Utilities;
-using Xunit;
-using LocalizableStrings = Microsoft.DotNet.Tools.Publish.LocalizableStrings;
-using System.Runtime.CompilerServices;
 using Microsoft.NET.TestFramework;
 using Microsoft.NET.TestFramework.Assertions;
 using Microsoft.NET.TestFramework.Commands;
+using Xunit;
 using Xunit.Abstractions;
+using LocalizableStrings = Microsoft.DotNet.Tools.Publish.LocalizableStrings;
 
 namespace Microsoft.DotNet.Cli.Publish.Tests
 {
diff --git a/src/Tests/dotnet-run.Tests/GivenDotnetRunRunsCsProj.cs b/src/Tests/dotnet-run.Tests/GivenDotnetRunRunsCsProj.cs
index 72f07ed74737..939afcbc618c 100644
--- a/src/Tests/dotnet-run.Tests/GivenDotnetRunRunsCsProj.cs
+++ b/src/Tests/dotnet-run.Tests/GivenDotnetRunRunsCsProj.cs
@@ -6,7 +6,6 @@
 using System.Xml.Linq;
 using FluentAssertions;
 using Microsoft.DotNet.Cli.Utils;
-using Microsoft.DotNet.PlatformAbstractions;
 using Microsoft.DotNet.Tools.Test.Utilities;
 using Microsoft.NET.TestFramework;
 using Microsoft.NET.TestFramework.Assertions;
@@ -545,7 +544,7 @@ public void ItRunsWithDotnetWithoutApphost()
                    .HaveStdOutContaining($"dotnet{Constants.ExeSuffix}");
         }
 
-        [PlatformSpecificFact(Platform.Windows, Platform.Linux, Platform.FreeBSD)]
+        [PlatformSpecificFact(TestPlatforms.Windows | TestPlatforms.Linux | TestPlatforms.FreeBSD)]
         public void ItRunsWithApphost()
         {
             var testInstance = _testAssetsManager.CopyTestAsset("AppOutputsExecutablePath").WithSource();
diff --git a/src/Tests/dotnet-store.Tests/GivenDotnetStoresAndPublishesProjects.cs b/src/Tests/dotnet-store.Tests/GivenDotnetStoresAndPublishesProjects.cs
index 2b38cdf71597..ad2745325ff2 100644
--- a/src/Tests/dotnet-store.Tests/GivenDotnetStoresAndPublishesProjects.cs
+++ b/src/Tests/dotnet-store.Tests/GivenDotnetStoresAndPublishesProjects.cs
@@ -2,13 +2,12 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 using FluentAssertions;
-using Microsoft.DotNet.PlatformAbstractions;
-using Microsoft.DotNet.Tools.Test.Utilities;
 using Microsoft.NET.TestFramework;
 using Microsoft.NET.TestFramework.Assertions;
 using Microsoft.NET.TestFramework.Commands;
 using System;
 using System.IO;
+using System.Runtime.InteropServices;
 using Xunit;
 using Xunit.Abstractions;
 
@@ -17,7 +16,7 @@ namespace Microsoft.DotNet.Cli.Publish.Tests
     public class GivenDotnetStoresAndPublishesProjects : SdkTest
     {
         private static string _tfm = "netcoreapp3.0";
-        private static string _arch = RuntimeEnvironment.RuntimeArchitecture.ToLowerInvariant();
+        private static string _arch = RuntimeInformation.ProcessArchitecture.ToString().ToLowerInvariant();
 
         public GivenDotnetStoresAndPublishesProjects(ITestOutputHelper log) : base(log)
         {
diff --git a/src/Tests/dotnet.Tests/GivenThatIWantToManageMulticoreJIT.cs b/src/Tests/dotnet.Tests/GivenThatIWantToManageMulticoreJIT.cs
index ac8bf711229f..13f3a6a73346 100644
--- a/src/Tests/dotnet.Tests/GivenThatIWantToManageMulticoreJIT.cs
+++ b/src/Tests/dotnet.Tests/GivenThatIWantToManageMulticoreJIT.cs
@@ -1,15 +1,12 @@
 // Copyright (c) .NET Foundation and contributors. All rights reserved. 
 // Licensed under the MIT license. See LICENSE file in the project root for full license information. 
 
-using Microsoft.DotNet.Cli.Utils;
-using Microsoft.DotNet.Tools.Test.Utilities;
 using System;
 using System.IO;
 using System.Runtime.InteropServices;
 using Xunit;
 using Xunit.Abstractions;
 using FluentAssertions;
-using Microsoft.DotNet.PlatformAbstractions;
 using Microsoft.NET.TestFramework;
 using Microsoft.NET.TestFramework.Assertions;
 using Microsoft.NET.TestFramework.Commands;
@@ -90,7 +87,7 @@ private static string GetUserProfileRoot(string overrideUserProfileRoot = null)
 
         private static string GetOptimizationRootPath(string version)
         {
-            var rid = PlatformAbstractions.RuntimeEnvironment.GetRuntimeIdentifier();
+            var rid = DotNet.Cli.Utils.RuntimeEnvironment.GetRuntimeIdentifier();
             
             return RuntimeInformation.IsOSPlatform(OSPlatform.Windows)
                 ? $@"Microsoft\dotnet\optimizationdata\{version}\{rid}" 
diff --git a/src/Tests/dotnet.Tests/TelemetryCommonPropertiesTests.cs b/src/Tests/dotnet.Tests/TelemetryCommonPropertiesTests.cs
index d8573c2a42f9..3c77cb4651db 100644
--- a/src/Tests/dotnet.Tests/TelemetryCommonPropertiesTests.cs
+++ b/src/Tests/dotnet.Tests/TelemetryCommonPropertiesTests.cs
@@ -2,13 +2,11 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 using FluentAssertions;
-using Microsoft.DotNet.Tools.Test.Utilities;
 using Xunit;
 using System;
 using System.Runtime.InteropServices;
 using Microsoft.DotNet.Cli.Telemetry;
 using Microsoft.DotNet.Configurer;
-using RuntimeEnvironment = Microsoft.DotNet.PlatformAbstractions.RuntimeEnvironment;
 using Microsoft.NET.TestFramework;
 using Xunit.Abstractions;
 
@@ -111,7 +109,7 @@ public void TelemetryCommonPropertiesShouldContainEmptyLibcReleaseAndVersion2()
         [LinuxOnlyFact]
         public void TelemetryCommonPropertiesShouldContainLibcReleaseAndVersion()
         {
-            if (!RuntimeEnvironment.OperatingSystem.Contains("Alpine", StringComparison.OrdinalIgnoreCase))
+            if (!DotNet.Cli.Utils.RuntimeEnvironment.OperatingSystem.Contains("Alpine", StringComparison.OrdinalIgnoreCase))
             {
                 var unitUnderTest = new TelemetryCommonProperties(getMACAddress: () => null, userLevelCacheWriter: new NothingCache());
                 unitUnderTest.GetTelemetryCommonProperties()["Libc Release"].Should().NotBeEmpty();
diff --git a/src/Tests/dotnet.Tests/dotnet.Tests.csproj b/src/Tests/dotnet.Tests/dotnet.Tests.csproj
index d941d47e70ce..ed6f1354c41b 100644
--- a/src/Tests/dotnet.Tests/dotnet.Tests.csproj
+++ b/src/Tests/dotnet.Tests/dotnet.Tests.csproj
@@ -146,7 +146,6 @@
 
   <ItemGroup>
     <PackageReference Include="Moq" Version="4.7.25" />
-    <PackageReference Include="Microsoft.DotNet.PlatformAbstractions" Version="$(MicrosoftDotNetPlatformAbstractionsPackageVersion)" />
     <PackageReference Include="Microsoft.DotNet.Cli.CommandLine" Version="$(MicrosoftDotNetCliCommandLinePackageVersion)" />
     <PackageReference Include="System.ComponentModel.TypeConverter" Version="4.3.0" />
   </ItemGroup>
diff --git a/toolset/eng/Versions.props b/toolset/eng/Versions.props
index b161c0b7c7ec..90125791b84c 100644
--- a/toolset/eng/Versions.props
+++ b/toolset/eng/Versions.props
@@ -102,7 +102,6 @@
     <MicrosoftNETCoreAppRefPackageVersion>5.0.0-alpha1.19518.1</MicrosoftNETCoreAppRefPackageVersion>
     <MicrosoftNETCoreAppRuntimewinx64PackageVersion>5.0.0-alpha1.19518.1</MicrosoftNETCoreAppRuntimewinx64PackageVersion>
     <MicrosoftNETCoreAppRuntimePackageVersion>$(MicrosoftNETCoreAppRuntimewinx64PackageVersion)</MicrosoftNETCoreAppRuntimePackageVersion>    
-    <MicrosoftDotNetPlatformAbstractionsPackageVersion>5.0.0-alpha1.19428.13</MicrosoftDotNetPlatformAbstractionsPackageVersion>
     <MicrosoftExtensionsDependencyModelPackageVersion>5.0.0-alpha1.19428.13</MicrosoftExtensionsDependencyModelPackageVersion>
     <MicrosoftNETCoreDotNetHostResolverPackageVersion>5.0.0-alpha1.19428.13</MicrosoftNETCoreDotNetHostResolverPackageVersion>
     <MicrosoftNETHostModelVersion>5.0.0-alpha1.19428.13</MicrosoftNETHostModelVersion>
@@ -111,7 +110,6 @@
     <NewtonsoftJsonPackageVersion>11.0.1</NewtonsoftJsonPackageVersion>
     <MicrosoftApplicationInsightsPackageVersion>2.0.0</MicrosoftApplicationInsightsPackageVersion>
     <MSTestVersion>1.3.2</MSTestVersion>
-    <MicrosoftDotNetPlatformAbstractionsPackageVersion>2.2.0-preview1-26620-03</MicrosoftDotNetPlatformAbstractionsPackageVersion>
     <MicrosoftDotNetCliUtilsPackageVersion>2.2.100-refac-20180613-1</MicrosoftDotNetCliUtilsPackageVersion>
     <XliffTasksPackageVersion>0.2.0-beta-000042</XliffTasksPackageVersion>
     <CLI_NETStandardLibraryNETFrameworkVersion>2.0.1-servicing-26011-01</CLI_NETStandardLibraryNETFrameworkVersion>
diff --git a/toolset/test/binding-redirects.Tests/binding-redirects.Tests.csproj b/toolset/test/binding-redirects.Tests/binding-redirects.Tests.csproj
index d9ff739e9766..f52560d3939d 100644
--- a/toolset/test/binding-redirects.Tests/binding-redirects.Tests.csproj
+++ b/toolset/test/binding-redirects.Tests/binding-redirects.Tests.csproj
@@ -10,8 +10,4 @@
   <ItemGroup>
     <ProjectReference Include="..\Microsoft.DotNet.Tools.Tests.Utilities\Microsoft.DotNet.Tools.Tests.Utilities.csproj" />
   </ItemGroup>
-
-  <ItemGroup>
-    <PackageReference Include="Microsoft.DotNet.PlatformAbstractions" Version="$(MicrosoftDotNetPlatformAbstractionsPackageVersion)" />
-  </ItemGroup>
 </Project>