diff --git a/build.cake b/build.cake
index 4b199e9a..f9b319ca 100644
--- a/build.cake
+++ b/build.cake
@@ -14,8 +14,7 @@ var NuGetSources = new [] { MakeAbsolute (Directory ("./output")).FullPath, "htt
 var NugetToolPath = GetToolPath ("nuget.exe");
 var XamarinComponentToolPath = GetToolPath ("xamarin-component.exe");
 var CakeToolPath = GetToolPath ("Cake/Cake.exe");
-var TestConsoleToolPath_x86 = GetToolPath ("xunit.runner.console/tools/xunit.console.x86.exe");
-var TestConsoleToolPath_x64 = GetToolPath ("xunit.runner.console/tools/xunit.console.exe");
+var NUnitConsoleToolPath = GetToolPath ("NUnit.Console/tools/nunit3-console.exe");
 var GenApiToolPath = GetToolPath ("Microsoft.DotNet.BuildTools.GenAPI/tools/GenAPI.exe");
 var MDocPath = GetToolPath ("mdoc/mdoc.exe");
 
@@ -217,19 +216,19 @@ Task ("tests")
             c.Configuration = "Release"; 
             c.Properties ["Platform"] = new [] { "x86" };
         });
-        RunTests("./tests/SkiaSharp.Desktop.Tests/bin/x86/Release/SkiaSharp.Desktop.Tests.dll", false);
+        RunTests("./tests/SkiaSharp.Desktop.Tests/bin/x86/Release/SkiaSharp.Desktop.Tests.dll");
         DotNetBuild ("./tests/SkiaSharp.Desktop.Tests/SkiaSharp.Desktop.Tests.sln", c => { 
             c.Configuration = "Release"; 
             c.Properties ["Platform"] = new [] { "x64" };
         });
-        RunTests("./tests/SkiaSharp.Desktop.Tests/bin/x64/Release/SkiaSharp.Desktop.Tests.dll", true);
+        RunTests("./tests/SkiaSharp.Desktop.Tests/bin/x64/Release/SkiaSharp.Desktop.Tests.dll");
     }
     // Mac OSX (Any CPU)
     if (IsRunningOnMac ()) {
         DotNetBuild ("./tests/SkiaSharp.Desktop.Tests/SkiaSharp.Desktop.Tests.sln", c => { 
             c.Configuration = "Release"; 
         });
-        RunTests("./tests/SkiaSharp.Desktop.Tests/bin/AnyCPU/Release/SkiaSharp.Desktop.Tests.dll", false);
+        RunTests("./tests/SkiaSharp.Desktop.Tests/bin/AnyCPU/Release/SkiaSharp.Desktop.Tests.dll");
     }
     // .NET Core
     RunDotNetCoreRestore ("./tests/SkiaSharp.NetCore.Tests");
@@ -664,8 +663,7 @@ Task ("Windows-CI")
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
 Information ("Cake.exe ToolPath: {0}", CakeToolPath);
-Information ("Cake.exe TestConsoleToolPath_x86: {0}", TestConsoleToolPath_x86);
-Information ("Cake.exe TestConsoleToolPath_x64: {0}", TestConsoleToolPath_x64);
+Information ("Cake.exe NUnitConsoleToolPath: {0}", NUnitConsoleToolPath);
 Information ("NuGet.exe ToolPath: {0}", NugetToolPath);
 Information ("Xamarin-Component.exe ToolPath: {0}", XamarinComponentToolPath);
 Information ("genapi.exe ToolPath: {0}", GenApiToolPath);
diff --git a/cake/UtilsManaged.cake b/cake/UtilsManaged.cake
index 78bf3fab..101e212d 100644
--- a/cake/UtilsManaged.cake
+++ b/cake/UtilsManaged.cake
@@ -39,11 +39,11 @@ var RunProcess = new Action<FilePath, ProcessSettings> ((process, settings) =>
     }
 });
 
-var RunTests = new Action<FilePath, bool> ((testAssembly, is64) =>
+var RunTests = new Action<FilePath> ((testAssembly) =>
 {
     var dir = testAssembly.GetDirectory ();
-    RunProcess (is64 ? TestConsoleToolPath_x64 : TestConsoleToolPath_x86, new ProcessSettings {
-        Arguments = string.Format ("\"{0}\"", testAssembly),
+    RunProcess (NUnitConsoleToolPath, new ProcessSettings {
+        Arguments = string.Format ("\"{0}\" --work=\"{1}\"", testAssembly, dir),
     });
 });
 
diff --git a/tests/SkiaSharp.Desktop.Tests/SkiaSharp.Desktop.Tests.csproj b/tests/SkiaSharp.Desktop.Tests/SkiaSharp.Desktop.Tests.csproj
index 4f70b09b..5aff5b90 100644
--- a/tests/SkiaSharp.Desktop.Tests/SkiaSharp.Desktop.Tests.csproj
+++ b/tests/SkiaSharp.Desktop.Tests/SkiaSharp.Desktop.Tests.csproj
@@ -1,6 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <Import Project="packages\xunit.runner.visualstudio.2.1.0\build\net20\xunit.runner.visualstudio.props" Condition="Exists('packages\xunit.runner.visualstudio.2.1.0\build\net20\xunit.runner.visualstudio.props')" />
   <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
   <PropertyGroup>
     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
@@ -74,6 +73,10 @@
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
   </PropertyGroup>
   <ItemGroup>
+    <Reference Include="nunit.framework, Version=3.6.0.0, Culture=neutral, PublicKeyToken=2638cd05610744eb, processorArchitecture=MSIL">
+      <HintPath>packages\NUnit.3.6.0\lib\net45\nunit.framework.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
     <Reference Include="System" />
     <Reference Include="System.Core" />
     <Reference Include="System.Drawing" />
@@ -83,22 +86,6 @@
     <Reference Include="System.Data" />
     <Reference Include="System.Net.Http" />
     <Reference Include="System.Xml" />
-    <Reference Include="xunit.abstractions">
-      <HintPath>packages\xunit.abstractions.2.0.0\lib\net35\xunit.abstractions.dll</HintPath>
-      <Private>True</Private>
-    </Reference>
-    <Reference Include="xunit.assert">
-      <HintPath>packages\xunit.assert.2.1.0\lib\dotnet\xunit.assert.dll</HintPath>
-      <Private>True</Private>
-    </Reference>
-    <Reference Include="xunit.core">
-      <HintPath>packages\xunit.extensibility.core.2.1.0\lib\dotnet\xunit.core.dll</HintPath>
-      <Private>True</Private>
-    </Reference>
-    <Reference Include="xunit.execution.desktop">
-      <HintPath>packages\xunit.extensibility.execution.2.1.0\lib\net45\xunit.execution.desktop.dll</HintPath>
-      <Private>True</Private>
-    </Reference>
   </ItemGroup>
   <ItemGroup>
     <Compile Include="..\Tests\GlContexts\Cgl\Cgl.cs">
@@ -285,12 +272,6 @@
   </ItemGroup>
   <Import Project="..\..\binding\SkiaSharp.Desktop\bin\$(Configuration)\nuget\build\net45\SkiaSharp.Desktop.targets" />
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
-  <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
-    <PropertyGroup>
-      <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
-    </PropertyGroup>
-    <Error Condition="!Exists('packages\xunit.runner.visualstudio.2.1.0\build\net20\xunit.runner.visualstudio.props')" Text="$([System.String]::Format('$(ErrorText)', 'packages\xunit.runner.visualstudio.2.1.0\build\net20\xunit.runner.visualstudio.props'))" />
-  </Target>
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
   <Target Name="BeforeBuild">
diff --git a/tests/SkiaSharp.Desktop.Tests/packages.config b/tests/SkiaSharp.Desktop.Tests/packages.config
index dcbf45ed..c67d69a7 100644
--- a/tests/SkiaSharp.Desktop.Tests/packages.config
+++ b/tests/SkiaSharp.Desktop.Tests/packages.config
@@ -1,10 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
-  <package id="xunit" version="2.1.0" targetFramework="net45" />
-  <package id="xunit.abstractions" version="2.0.0" targetFramework="net45" />
-  <package id="xunit.assert" version="2.1.0" targetFramework="net45" />
-  <package id="xunit.core" version="2.1.0" targetFramework="net45" />
-  <package id="xunit.extensibility.core" version="2.1.0" targetFramework="net45" />
-  <package id="xunit.extensibility.execution" version="2.1.0" targetFramework="net45" />
-  <package id="xunit.runner.visualstudio" version="2.1.0" targetFramework="net45" />
+  <package id="NUnit" version="3.6.0" targetFramework="net45" />
+  <package id="NUnit3TestAdapter" version="3.7.0" targetFramework="net45" />
 </packages>
\ No newline at end of file
diff --git a/tests/SkiaSharp.NetCore.Tests/project.json b/tests/SkiaSharp.NetCore.Tests/project.json
index 7b6ba824..fb71a194 100644
--- a/tests/SkiaSharp.NetCore.Tests/project.json
+++ b/tests/SkiaSharp.NetCore.Tests/project.json
@@ -20,13 +20,13 @@
         }
     },
     "dependencies": {
-        "xunit": "2.2.0-beta5-build3474",
-        "dotnet-test-xunit": "2.2.0-preview2-build1029",
+        "NUnit": "3.6.0",
+        "dotnet-test-nunit": "3.4.0-beta-3",
 
         "SkiaSharp": "1.56.1",
         "SkiaSharp.Svg": "1.56.1"
     },
-    "testRunner": "xunit",
+    "testRunner": "nunit",
     "frameworks": {
         "netcoreapp1.0": {
             "dependencies": {
diff --git a/tests/Tests/GRContextTest.cs b/tests/Tests/GRContextTest.cs
index ea0da76c..afc51914 100644
--- a/tests/Tests/GRContextTest.cs
+++ b/tests/Tests/GRContextTest.cs
@@ -1,12 +1,13 @@
 using System;
 using System.Collections.Generic;
-using Xunit;
+using NUnit.Framework;
 
 namespace SkiaSharp.Tests
 {
+	[Parallelizable(ParallelScope.None)]
 	public class GRContextTest : SKTest
 	{
-		[Fact]
+		[Test]
 		public void CreateDefaultContextIsValid()
 		{
 			using (var ctx = CreateGlContext()) {
@@ -18,7 +19,7 @@ namespace SkiaSharp.Tests
 			}
 		}
 
-		[Fact]
+		[Test]
 		public void CreateSpecificContextIsValid()
 		{
 			using (var ctx = CreateGlContext()) {
diff --git a/tests/Tests/GRGlInterfaceTest.cs b/tests/Tests/GRGlInterfaceTest.cs
index 55518ea7..90f2c176 100644
--- a/tests/Tests/GRGlInterfaceTest.cs
+++ b/tests/Tests/GRGlInterfaceTest.cs
@@ -1,13 +1,14 @@
 using System;
 using System.Collections.Generic;
 using System.Runtime.InteropServices;
-using Xunit;
+using NUnit.Framework;
 
 namespace SkiaSharp.Tests
 {
+	[Parallelizable(ParallelScope.None)]
 	public class GRGlInterfaceTest : SKTest
 	{
-		[Fact]
+		[Test]
 		public void CreateDefaultInterfaceIsValid()
 		{
 			using (var ctx = CreateGlContext()) {
diff --git a/tests/Tests/SKBasicTypesTest.cs b/tests/Tests/SKBasicTypesTest.cs
index a0a9ffee..1eba7b7d 100644
--- a/tests/Tests/SKBasicTypesTest.cs
+++ b/tests/Tests/SKBasicTypesTest.cs
@@ -1,6 +1,6 @@
 using System;
 using System.Collections.Generic;
-using Xunit;
+using NUnit.Framework;
 
 namespace SkiaSharp.Tests
 {
@@ -8,24 +8,24 @@ namespace SkiaSharp.Tests
 	{
 		private const float EPSILON = 0.0001f;
 
-		[Fact]
+		[Test]
 		public void RectanlgeHasCorrectProperties()
 		{
 			var rect = new SKRect(15, 25, 55, 75);
 
-			Assert.Equal(15f, rect.Left);
-			Assert.Equal(25f, rect.Top);
-			Assert.Equal(55f, rect.Right);
-			Assert.Equal(75f, rect.Bottom);
+			Assert.AreEqual(15f, rect.Left);
+			Assert.AreEqual(25f, rect.Top);
+			Assert.AreEqual(55f, rect.Right);
+			Assert.AreEqual(75f, rect.Bottom);
 
-			Assert.Equal(40f, rect.Width);
-			Assert.Equal(50f, rect.Height);
+			Assert.AreEqual(40f, rect.Width);
+			Assert.AreEqual(50f, rect.Height);
 
-			Assert.Equal(35f, rect.MidX);
-			Assert.Equal(50f, rect.MidY);
+			Assert.AreEqual(35f, rect.MidX);
+			Assert.AreEqual(50f, rect.MidY);
 		}
 
-		[Fact]
+		[Test]
 		public void RectanlgeOffsetsCorrectly()
 		{
 			var expected = new SKRect(25, 30, 65, 80);
@@ -36,54 +36,54 @@ namespace SkiaSharp.Tests
 			var rect2 = new SKRect(15, 25, 55, 75);
 			rect2.Offset (10, 5);
 
-			Assert.Equal(expected, rect1);
-			Assert.Equal(expected, rect2);
+			Assert.AreEqual(expected, rect1);
+			Assert.AreEqual(expected, rect2);
 		}
 
-		[Fact]
+		[Test]
 		public void RectanlgeInflatesCorrectly()
 		{
 			var rect = new SKRect(15, 25, 55, 75);
 
-			Assert.Equal(15f, rect.Left);
-			Assert.Equal(25f, rect.Top);
-			Assert.Equal(55f, rect.Right);
-			Assert.Equal(75f, rect.Bottom);
+			Assert.AreEqual(15f, rect.Left);
+			Assert.AreEqual(25f, rect.Top);
+			Assert.AreEqual(55f, rect.Right);
+			Assert.AreEqual(75f, rect.Bottom);
 
 			rect.Inflate(10, 20);
 
-			Assert.Equal(5f, rect.Left);
-			Assert.Equal(5f, rect.Top);
-			Assert.Equal(65f, rect.Right);
-			Assert.Equal(95f, rect.Bottom);
+			Assert.AreEqual(5f, rect.Left);
+			Assert.AreEqual(5f, rect.Top);
+			Assert.AreEqual(65f, rect.Right);
+			Assert.AreEqual(95f, rect.Bottom);
 		}
 
-		[Fact]
+		[Test]
 		public void RectanlgeStandardizeCorrectly()
 		{
 			var rect = new SKRect(5, 5, 15, 15);
-			Assert.Equal(10, rect.Width);
-			Assert.Equal(10, rect.Height);
+			Assert.AreEqual(10, rect.Width);
+			Assert.AreEqual(10, rect.Height);
 
-			Assert.Equal(rect, rect.Standardized);
+			Assert.AreEqual(rect, rect.Standardized);
 
 			var negW = new SKRect(15, 5, 5, 15);
-			Assert.Equal(-10, negW.Width);
-			Assert.Equal(10, negW.Height);
-			Assert.Equal(rect, negW.Standardized);
+			Assert.AreEqual(-10, negW.Width);
+			Assert.AreEqual(10, negW.Height);
+			Assert.AreEqual(rect, negW.Standardized);
 
 			var negH = new SKRect(5, 15, 15, 5);
-			Assert.Equal(10, negH.Width);
-			Assert.Equal(-10, negH.Height);
-			Assert.Equal(rect, negH.Standardized);
+			Assert.AreEqual(10, negH.Width);
+			Assert.AreEqual(-10, negH.Height);
+			Assert.AreEqual(rect, negH.Standardized);
 
 			var negWH = new SKRect(15, 15, 5, 5);
-			Assert.Equal(-10, negWH.Width);
-			Assert.Equal(-10, negWH.Height);
-			Assert.Equal(rect, negWH.Standardized);
+			Assert.AreEqual(-10, negWH.Width);
+			Assert.AreEqual(-10, negWH.Height);
+			Assert.AreEqual(rect, negWH.Standardized);
 		}
 
-		[Fact]
+		[Test]
 		public void RectanlgeAspectFitIsCorrect()
 		{
 			var bigRect = SKRect.Create(5, 5, 20, 20);
@@ -91,19 +91,19 @@ namespace SkiaSharp.Tests
 			var wideSize = new SKSize(10, 5);
 
 			var fitTall = bigRect.AspectFit(tallSize);
-			Assert.Equal(5 + 5, fitTall.Left);
-			Assert.Equal(5 + 0, fitTall.Top);
-			Assert.Equal(10, fitTall.Width);
-			Assert.Equal(20, fitTall.Height);
+			Assert.AreEqual(5 + 5, fitTall.Left);
+			Assert.AreEqual(5 + 0, fitTall.Top);
+			Assert.AreEqual(10, fitTall.Width);
+			Assert.AreEqual(20, fitTall.Height);
 
 			var fitWide = bigRect.AspectFit(wideSize);
-			Assert.Equal(5 + 0, fitWide.Left);
-			Assert.Equal(5 + 5, fitWide.Top);
-			Assert.Equal(20, fitWide.Width);
-			Assert.Equal(10, fitWide.Height);
+			Assert.AreEqual(5 + 0, fitWide.Left);
+			Assert.AreEqual(5 + 5, fitWide.Top);
+			Assert.AreEqual(20, fitWide.Width);
+			Assert.AreEqual(10, fitWide.Height);
 		}
 
-		[Fact]
+		[Test]
 		public void RectanlgeAspectFillIsCorrect()
 		{
 			var bigRect = SKRect.Create(5, 5, 20, 20);
@@ -111,19 +111,19 @@ namespace SkiaSharp.Tests
 			var wideSize = new SKSize(10, 5);
 
 			var fitTall = bigRect.AspectFill(tallSize);
-			Assert.Equal(5 + 0, fitTall.Left);
-			Assert.Equal(5 - 10, fitTall.Top);
-			Assert.Equal(20, fitTall.Width);
-			Assert.Equal(40, fitTall.Height);
+			Assert.AreEqual(5 + 0, fitTall.Left);
+			Assert.AreEqual(5 - 10, fitTall.Top);
+			Assert.AreEqual(20, fitTall.Width);
+			Assert.AreEqual(40, fitTall.Height);
 
 			var fitWide = bigRect.AspectFill(wideSize);
-			Assert.Equal(5 - 10, fitWide.Left);
-			Assert.Equal(5 + 0, fitWide.Top);
-			Assert.Equal(40, fitWide.Width);
-			Assert.Equal(20, fitWide.Height);
+			Assert.AreEqual(5 - 10, fitWide.Left);
+			Assert.AreEqual(5 + 0, fitWide.Top);
+			Assert.AreEqual(40, fitWide.Width);
+			Assert.AreEqual(20, fitWide.Height);
 		}
 		
-		[Fact]
+		[Test]
 		public unsafe void FixedImageMaskIsHandledCorrectly()
 		{
 			byte rawMask = 1 << 7 | 0 << 6 | 0 << 5 | 1 << 4 | 1 << 3 | 0 << 2 | 1 << 1 | 1;
@@ -136,11 +136,11 @@ namespace SkiaSharp.Tests
 			{
 				var mask = SKMask.Create(buffer, bounds, rowBytes, format);
 
-				Assert.Equal(rawMask, mask.GetAddr1(0, 0));
+				Assert.AreEqual(rawMask, mask.GetAddr1(0, 0));
 			}
 		}
 
-		[Fact]
+		[Test]
 		public void MonochromeMaskBufferIsCopied()
 		{
 			byte rawMask = 1 << 7 | 0 << 6 | 0 << 5 | 1 << 4 | 1 << 3 | 0 << 2 | 1 << 1 | 1;
@@ -151,12 +151,12 @@ namespace SkiaSharp.Tests
 
 			var mask = SKMask.Create(buffer, bounds, rowBytes, format);
 
-			Assert.Equal(rawMask, mask.GetAddr1(0, 0));
+			Assert.AreEqual(rawMask, mask.GetAddr1(0, 0));
 
 			mask.FreeImage();
 		}
 
-		[Fact]
+		[Test]
 		public void Alpha8MaskBufferIsCopied()
 		{
 			var buffer = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8 };
@@ -166,19 +166,19 @@ namespace SkiaSharp.Tests
 
 			var mask = SKMask.Create(buffer, bounds, rowBytes, format);
 
-			Assert.Equal(buffer[0], mask.GetAddr8(0, 0));
-			Assert.Equal(buffer[1], mask.GetAddr8(1, 0));
-			Assert.Equal(buffer[2], mask.GetAddr8(2, 0));
-			Assert.Equal(buffer[3], mask.GetAddr8(3, 0));
-			Assert.Equal(buffer[4], mask.GetAddr8(0, 1));
-			Assert.Equal(buffer[5], mask.GetAddr8(1, 1));
-			Assert.Equal(buffer[6], mask.GetAddr8(2, 1));
-			Assert.Equal(buffer[7], mask.GetAddr8(3, 1));
+			Assert.AreEqual(buffer[0], mask.GetAddr8(0, 0));
+			Assert.AreEqual(buffer[1], mask.GetAddr8(1, 0));
+			Assert.AreEqual(buffer[2], mask.GetAddr8(2, 0));
+			Assert.AreEqual(buffer[3], mask.GetAddr8(3, 0));
+			Assert.AreEqual(buffer[4], mask.GetAddr8(0, 1));
+			Assert.AreEqual(buffer[5], mask.GetAddr8(1, 1));
+			Assert.AreEqual(buffer[6], mask.GetAddr8(2, 1));
+			Assert.AreEqual(buffer[7], mask.GetAddr8(3, 1));
 
 			mask.FreeImage();
 		}
 
-		[Fact]
+		[Test]
 		public void ThirtyTwoBitMaskBufferIsCopied()
 		{
 			var buffer = new byte[]
@@ -200,14 +200,14 @@ namespace SkiaSharp.Tests
 
 			var red = SKColors.Red;
 			var blue = SKColors.Blue;
-			Assert.Equal((uint)red, mask.GetAddr32(0, 0));
-			Assert.Equal((uint)blue, mask.GetAddr32(1, 0));
-			Assert.Equal((uint)red, mask.GetAddr32(2, 0));
-			Assert.Equal((uint)blue, mask.GetAddr32(3, 0));
-			Assert.Equal((uint)red, mask.GetAddr32(0, 1));
-			Assert.Equal((uint)blue, mask.GetAddr32(1, 1));
-			Assert.Equal((uint)red, mask.GetAddr32(2, 1));
-			Assert.Equal((uint)blue, mask.GetAddr32(3, 1));
+			Assert.AreEqual((uint)red, mask.GetAddr32(0, 0));
+			Assert.AreEqual((uint)blue, mask.GetAddr32(1, 0));
+			Assert.AreEqual((uint)red, mask.GetAddr32(2, 0));
+			Assert.AreEqual((uint)blue, mask.GetAddr32(3, 0));
+			Assert.AreEqual((uint)red, mask.GetAddr32(0, 1));
+			Assert.AreEqual((uint)blue, mask.GetAddr32(1, 1));
+			Assert.AreEqual((uint)red, mask.GetAddr32(2, 1));
+			Assert.AreEqual((uint)blue, mask.GetAddr32(3, 1));
 
 			mask.FreeImage();
 		}
diff --git a/tests/Tests/SKBitmapTest.cs b/tests/Tests/SKBitmapTest.cs
index 834fca2f..07786951 100644
--- a/tests/Tests/SKBitmapTest.cs
+++ b/tests/Tests/SKBitmapTest.cs
@@ -1,13 +1,13 @@
 using System;
 using System.IO;
 using System.Runtime.InteropServices;
-using Xunit;
+using NUnit.Framework;
 
 namespace SkiaSharp.Tests
 {
 	public class SKBitmapTest : SKTest
 	{
-		[Fact]
+		[Test]
 		public void ReleaseBitmapPixelsWasInvoked()
 		{
 			bool released = false;
@@ -27,7 +27,7 @@ namespace SkiaSharp.Tests
 			Assert.True(released, "The SKBitmapReleaseDelegate was not called.");
 		}
 
-		[Fact]
+		[Test]
 		public void ReleaseBitmapPixelsWithNullDelegate()
 		{
 			var info = new SKImageInfo(1, 1);
@@ -40,7 +40,7 @@ namespace SkiaSharp.Tests
 			Marshal.FreeCoTaskMem(pixels);
 		}
 
-		[Fact]
+		[Test]
 		public void TestExtractAlpha()
 		{
 			var path = Path.Combine(PathToImages, "color-wheel.png");
@@ -55,30 +55,30 @@ namespace SkiaSharp.Tests
 
 			Assert.True(bitmap.ExtractAlpha(alpha, paint, out offset));
 
-			Assert.Equal(new SKPointI(-7, -7), offset);
+			Assert.AreEqual(new SKPointI(-7, -7), offset);
 		}
 
-		[Fact]
+		[Test]
 		public void BitmapAndPixmapAreValid()
 		{
 			var info = new SKImageInfo(10, 10);
 			using (var bitmap = new SKBitmap(info)) {
-				Assert.Equal(10, bitmap.Width);
-				Assert.Equal(10, bitmap.Height);
+				Assert.AreEqual(10, bitmap.Width);
+				Assert.AreEqual(10, bitmap.Height);
 
 				var pixmap = bitmap.PeekPixels();
 				Assert.NotNull(pixmap);
 
-				Assert.Equal(10, pixmap.Width);
-				Assert.Equal(10, pixmap.Height);
+				Assert.AreEqual(10, pixmap.Width);
+				Assert.AreEqual(10, pixmap.Height);
 
 				Assert.True(bitmap.GetPixels() != IntPtr.Zero);
 				Assert.True(pixmap.GetPixels() != IntPtr.Zero);
-				Assert.Equal(bitmap.GetPixels(), pixmap.GetPixels());
+				Assert.AreEqual(bitmap.GetPixels(), pixmap.GetPixels());
 			}
 		}
 
-		[Fact]
+		[Test]
 		public void BitmapResizes()
 		{
 			var srcInfo = new SKImageInfo(200, 200);
@@ -92,17 +92,17 @@ namespace SkiaSharp.Tests
 				canvas.DrawRect(new SKRect(0, 0, 100, 200), paint);
 			}
 
-			Assert.Equal(SKColors.Green, srcBmp.GetPixel(75, 75));
-			Assert.Equal(SKColors.Blue, srcBmp.GetPixel(175, 175));
+			Assert.AreEqual(SKColors.Green, srcBmp.GetPixel(75, 75));
+			Assert.AreEqual(SKColors.Blue, srcBmp.GetPixel(175, 175));
 
 			var dstBmp = srcBmp.Resize(dstInfo, SKBitmapResizeMethod.Mitchell);
 			Assert.NotNull(dstBmp);
 
-			Assert.Equal(SKColors.Green, dstBmp.GetPixel(25, 25));
-			Assert.Equal(SKColors.Blue, dstBmp.GetPixel(75, 75));
+			Assert.AreEqual(SKColors.Green, dstBmp.GetPixel(25, 25));
+			Assert.AreEqual(SKColors.Blue, dstBmp.GetPixel(75, 75));
 		}
 
-		[Fact]
+		[Test]
 		public void AlphaMaskIsApplied()
 		{
 			var srcInfo = new SKImageInfo(4, 4);
@@ -112,7 +112,7 @@ namespace SkiaSharp.Tests
 
 			foreach (var pixel in pixels)
 			{
-				Assert.Equal(255, pixel.Alpha);
+				Assert.AreEqual(255, pixel.Alpha);
 			}
 			
 			var maskBuffer = new byte[]
@@ -130,22 +130,22 @@ namespace SkiaSharp.Tests
 			srcBmp.InstallMaskPixels(mask);
 
 			pixels = srcBmp.Pixels;
-			Assert.Equal(128, pixels[0].Alpha);
-			Assert.Equal(127, pixels[1].Alpha);
-			Assert.Equal(126, pixels[2].Alpha);
-			Assert.Equal(125, pixels[3].Alpha);
-			Assert.Equal(101, pixels[4].Alpha);
-			Assert.Equal(102, pixels[5].Alpha);
-			Assert.Equal(103, pixels[6].Alpha);
-			Assert.Equal(104, pixels[7].Alpha);
-			Assert.Equal(96, pixels[8].Alpha);
-			Assert.Equal(95, pixels[9].Alpha);
-			Assert.Equal(94, pixels[10].Alpha);
-			Assert.Equal(93, pixels[11].Alpha);
-			Assert.Equal(72, pixels[12].Alpha);
-			Assert.Equal(73, pixels[13].Alpha);
-			Assert.Equal(74, pixels[14].Alpha);
-			Assert.Equal(75, pixels[15].Alpha);
+			Assert.AreEqual(128, pixels[0].Alpha);
+			Assert.AreEqual(127, pixels[1].Alpha);
+			Assert.AreEqual(126, pixels[2].Alpha);
+			Assert.AreEqual(125, pixels[3].Alpha);
+			Assert.AreEqual(101, pixels[4].Alpha);
+			Assert.AreEqual(102, pixels[5].Alpha);
+			Assert.AreEqual(103, pixels[6].Alpha);
+			Assert.AreEqual(104, pixels[7].Alpha);
+			Assert.AreEqual(96, pixels[8].Alpha);
+			Assert.AreEqual(95, pixels[9].Alpha);
+			Assert.AreEqual(94, pixels[10].Alpha);
+			Assert.AreEqual(93, pixels[11].Alpha);
+			Assert.AreEqual(72, pixels[12].Alpha);
+			Assert.AreEqual(73, pixels[13].Alpha);
+			Assert.AreEqual(74, pixels[14].Alpha);
+			Assert.AreEqual(75, pixels[15].Alpha);
 
 			mask.FreeImage();
 		}
diff --git a/tests/Tests/SKCodecTest.cs b/tests/Tests/SKCodecTest.cs
index c1cb76c6..931a0353 100644
--- a/tests/Tests/SKCodecTest.cs
+++ b/tests/Tests/SKCodecTest.cs
@@ -1,44 +1,44 @@
 using System;
 using System.IO;
 using System.Linq;
-using Xunit;
+using NUnit.Framework;
 
 namespace SkiaSharp.Tests
 {
 	public class SKCodecTest : SKTest
 	{
-		[Fact]
+		[Test]
 		public void MinBufferedBytesNeededHasAValue ()
 		{
 			Assert.True (SKCodec.MinBufferedBytesNeeded > 0);
 		}
 
-		[Fact]
+		[Test]
 		public void CanCreateStreamCodec ()
 		{
 			var stream = new SKFileStream (Path.Combine (PathToImages, "color-wheel.png"));
 			using (var codec = SKCodec.Create (stream)) {
-				Assert.Equal (SKEncodedFormat.Png, codec.EncodedFormat);
-				Assert.Equal (128, codec.Info.Width);
-				Assert.Equal (128, codec.Info.Height);
-				Assert.Equal (SKAlphaType.Unpremul, codec.Info.AlphaType);
-				Assert.Equal (SKImageInfo.PlatformColorType, codec.Info.ColorType);
+				Assert.AreEqual (SKEncodedFormat.Png, codec.EncodedFormat);
+				Assert.AreEqual (128, codec.Info.Width);
+				Assert.AreEqual (128, codec.Info.Height);
+				Assert.AreEqual (SKAlphaType.Unpremul, codec.Info.AlphaType);
+				Assert.AreEqual (SKImageInfo.PlatformColorType, codec.Info.ColorType);
 			}
 		}
 		
-		[Fact]
+		[Test]
 		public void GetGifFrames ()
 		{
 			const int FrameCount = 16;
 
 			var stream = new SKFileStream (Path.Combine (PathToImages, "animated-heart.gif"));
 			using (var codec = SKCodec.Create (stream)) {
-				Assert.Equal (-1, codec.RepetitionCount);
+				Assert.AreEqual (-1, codec.RepetitionCount);
 
 				var frameInfos = codec.FrameInfo;
-				Assert.Equal (FrameCount, frameInfos.Length);
+				Assert.AreEqual (FrameCount, frameInfos.Length);
 
-				Assert.Equal (-1, frameInfos [0].RequiredFrame);
+				Assert.AreEqual (-1, frameInfos [0].RequiredFrame);
 
 				var cachedFrames = new SKBitmap [FrameCount];
 				var info = new SKImageInfo (codec.Info.Width, codec.Info.Height);
@@ -52,7 +52,7 @@ namespace SkiaSharp.Tests
 					}
 					var opts = new SKCodecOptions (index, cached);
 					var result = codec.GetPixels (info, bm.GetPixels (), opts);
-					Assert.Equal (SKCodecResult.Success, result);
+					Assert.AreEqual (SKCodecResult.Success, result);
 				});
 
 				for (var i = 0; i < FrameCount; i++) {
@@ -62,33 +62,33 @@ namespace SkiaSharp.Tests
 					var uncachedFrame = new SKBitmap (info);
 					decode (uncachedFrame, false, i);
 
-					Assert.Equal (cachedFrame.Bytes, uncachedFrame.Bytes);
+					Assert.AreEqual (cachedFrame.Bytes, uncachedFrame.Bytes);
 				}
 			}
 		}
 
-		[Fact]
+		[Test]
 		public void GetEncodedInfo ()
 		{
 			var stream = new SKFileStream (Path.Combine (PathToImages, "color-wheel.png"));
 			using (var codec = SKCodec.Create (stream)) {
-				Assert.Equal (SKEncodedInfoColor.Rgba, codec.EncodedInfo.Color);
-				Assert.Equal (SKEncodedInfoAlpha.Unpremul, codec.EncodedInfo.Alpha);
-				Assert.Equal (8, codec.EncodedInfo.BitsPerComponent);
+				Assert.AreEqual (SKEncodedInfoColor.Rgba, codec.EncodedInfo.Color);
+				Assert.AreEqual (SKEncodedInfoAlpha.Unpremul, codec.EncodedInfo.Alpha);
+				Assert.AreEqual (8, codec.EncodedInfo.BitsPerComponent);
 			}
 		}
 
-		[Fact]
+		[Test]
 		public void CanGetPixels ()
 		{
 			var stream = new SKFileStream (Path.Combine (PathToImages, "baboon.png"));
 			using (var codec = SKCodec.Create (stream)) {
 				var pixels = codec.Pixels;
-				Assert.Equal (codec.Info.BytesSize, pixels.Length);
+				Assert.AreEqual (codec.Info.BytesSize, pixels.Length);
 			}
 		}
 
-		[Fact]
+		[Test]
 		public void DecodeImageScanlines ()
 		{
 			var path = Path.Combine (PathToImages, "CMYK.jpg");
@@ -104,37 +104,37 @@ namespace SkiaSharp.Tests
 					scanlineBitmap.Erase (SKColors.Fuchsia);
 
 					var result = codec.StartScanlineDecode (info);
-					Assert.Equal (SKCodecResult.Success, result);
+					Assert.AreEqual (SKCodecResult.Success, result);
 
-					Assert.Equal (SKCodecScanlineOrder.TopDown, codec.ScanlineOrder);
-					Assert.Equal (0, codec.NextScanline);
+					Assert.AreEqual (SKCodecScanlineOrder.TopDown, codec.ScanlineOrder);
+					Assert.AreEqual (0, codec.NextScanline);
 
 					// only decode every second line
 					for	(int y = 0; y < info.Height; y += 2) {
-						Assert.Equal (1, codec.GetScanlines (scanlineBitmap.GetAddr (0, y), 1, info.RowBytes));
-						Assert.Equal (y + 1, codec.NextScanline);
+						Assert.AreEqual (1, codec.GetScanlines (scanlineBitmap.GetAddr (0, y), 1, info.RowBytes));
+						Assert.AreEqual (y + 1, codec.NextScanline);
 						if (codec.SkipScanlines (1))
-							Assert.Equal (y + 2, codec.NextScanline);
+							Assert.AreEqual (y + 2, codec.NextScanline);
 						else
-							Assert.Equal (imageHeight, codec.NextScanline); // reached the end
+							Assert.AreEqual (imageHeight, codec.NextScanline); // reached the end
 					}
 
 					Assert.False (codec.SkipScanlines (1));
-					Assert.Equal (imageHeight, codec.NextScanline);
+					Assert.AreEqual (imageHeight, codec.NextScanline);
 
 					for (var x = 0; x < info.Width; x++) {
 						for (var y = 0; y < info.Height; y++) {
 							if (y % 2 == 0)
-								Assert.Equal (correctBitmap.GetPixel (x, y), scanlineBitmap.GetPixel (x, y));
+								Assert.AreEqual (correctBitmap.GetPixel (x, y), scanlineBitmap.GetPixel (x, y));
 							else
-								Assert.Equal (SKColors.Fuchsia, scanlineBitmap.GetPixel (x, y));
+								Assert.AreEqual (SKColors.Fuchsia, scanlineBitmap.GetPixel (x, y));
 						}
 					}
 				}
 			}
 		}
 
-		[Fact]
+		[Test]
 		public void DecodePartialImage ()
 		{
 			// read the data here, so we can fake a throttle/download
@@ -166,7 +166,7 @@ namespace SkiaSharp.Tests
 					var result = codec.StartIncrementalDecode (info, pixels, info.RowBytes);
 
 					// make sure the start was successful
-					Assert.Equal (SKCodecResult.Success, result);
+					Assert.AreEqual (SKCodecResult.Success, result);
 					result = SKCodecResult.IncompleteInput;
 
 					while (result == SKCodecResult.IncompleteInput) {
@@ -182,12 +182,12 @@ namespace SkiaSharp.Tests
 					}
 
 					// compare to original
-					Assert.Equal (correctBytes, incremental.Pixels);
+					Assert.AreEqual (correctBytes, incremental.Pixels);
 				}
 			}
 		}
 
-		[Fact]
+		[Test]
 		public void BitmapDecodesCorrectly ()
 		{
 			byte[] codecPixels;
@@ -201,10 +201,10 @@ namespace SkiaSharp.Tests
 				bitmapPixels = bitmap.Bytes;
 			}
 
-			Assert.Equal (codecPixels, bitmapPixels);
+			Assert.AreEqual (codecPixels, bitmapPixels);
 		}
 
-		[Fact]
+		[Test]
 		public void BitmapDecodesCorrectlyWithManagedStream ()
 		{
 			byte[] codecPixels;
@@ -219,7 +219,7 @@ namespace SkiaSharp.Tests
 				bitmapPixels = bitmap.Bytes;
 			}
 
-			Assert.Equal (codecPixels, bitmapPixels);
+			Assert.AreEqual (codecPixels, bitmapPixels);
 		}
 	}
 }
diff --git a/tests/Tests/SKColorTableTest.cs b/tests/Tests/SKColorTableTest.cs
index 8a1ead96..a18f9c9a 100644
--- a/tests/Tests/SKColorTableTest.cs
+++ b/tests/Tests/SKColorTableTest.cs
@@ -1,6 +1,6 @@
 using System;
 using System.Runtime.InteropServices;
-using Xunit;
+using NUnit.Framework;
 
 namespace SkiaSharp.Tests
 {
@@ -15,23 +15,23 @@ namespace SkiaSharp.Tests
 			SKColors.Blue 
 		};
 
-		[Fact]
+		[Test]
 		public void MembersRetrieveColors()
 		{
 			var colorTable = new SKColorTable(Colors);
 
-			Assert.Equal(Colors.Length, colorTable.Count);
+			Assert.AreEqual(Colors.Length, colorTable.Count);
 
-			Assert.Equal(Colors, colorTable.Colors);
+			Assert.AreEqual(Colors, colorTable.Colors);
 
-			Assert.Equal(Colors[0], colorTable[0]);
-			Assert.Equal(Colors[1], colorTable[1]);
-			Assert.Equal(Colors[2], colorTable[2]);
-			Assert.Equal(Colors[3], colorTable[3]);
-			Assert.Equal(Colors[4], colorTable[4]);
+			Assert.AreEqual(Colors[0], colorTable[0]);
+			Assert.AreEqual(Colors[1], colorTable[1]);
+			Assert.AreEqual(Colors[2], colorTable[2]);
+			Assert.AreEqual(Colors[3], colorTable[3]);
+			Assert.AreEqual(Colors[4], colorTable[4]);
 		}
 
-		[Fact]
+		[Test]
 		public void IndexerOutOfRangeBelow()
 		{
 			var colorTable = new SKColorTable(Colors);
@@ -42,7 +42,7 @@ namespace SkiaSharp.Tests
 			});
 		}
 
-		[Fact]
+		[Test]
 		public void IndexerOutOfRangeAbove()
 		{
 			var colorTable = new SKColorTable(Colors);
diff --git a/tests/Tests/SKColorTest.cs b/tests/Tests/SKColorTest.cs
index b09a9aa3..b53d7577 100644
--- a/tests/Tests/SKColorTest.cs
+++ b/tests/Tests/SKColorTest.cs
@@ -1,6 +1,6 @@
 using System;
 using System.Collections.Generic;
-using Xunit;
+using NUnit.Framework;
 
 using SKOtherColor = System.Tuple<float, float, float>;
 using ToOtherColor = System.Tuple<SkiaSharp.SKColor, System.Tuple<float, float, float>, string>;
@@ -11,41 +11,41 @@ namespace SkiaSharp.Tests
 	{
 		private const int Precision = 2;
 
-		[Fact]
+		[Test]
 		public void ColorWithComponent()
 		{
 			var color = new SKColor();
-			Assert.Equal(0, color.Red);
-			Assert.Equal(0, color.Green);
-			Assert.Equal(0, color.Blue);
-			Assert.Equal(0, color.Alpha);
+			Assert.AreEqual(0, color.Red);
+			Assert.AreEqual(0, color.Green);
+			Assert.AreEqual(0, color.Blue);
+			Assert.AreEqual(0, color.Alpha);
 
 			var red = color.WithRed(255);
-			Assert.Equal(255, red.Red);
-			Assert.Equal(0, red.Green);
-			Assert.Equal(0, red.Blue);
-			Assert.Equal(0, red.Alpha);
+			Assert.AreEqual(255, red.Red);
+			Assert.AreEqual(0, red.Green);
+			Assert.AreEqual(0, red.Blue);
+			Assert.AreEqual(0, red.Alpha);
 
 			var green = color.WithGreen(255);
-			Assert.Equal(0, green.Red);
-			Assert.Equal(255, green.Green);
-			Assert.Equal(0, green.Blue);
-			Assert.Equal(0, green.Alpha);
+			Assert.AreEqual(0, green.Red);
+			Assert.AreEqual(255, green.Green);
+			Assert.AreEqual(0, green.Blue);
+			Assert.AreEqual(0, green.Alpha);
 
 			var blue = color.WithBlue(255);
-			Assert.Equal(0, blue.Red);
-			Assert.Equal(0, blue.Green);
-			Assert.Equal(255, blue.Blue);
-			Assert.Equal(0, blue.Alpha);
+			Assert.AreEqual(0, blue.Red);
+			Assert.AreEqual(0, blue.Green);
+			Assert.AreEqual(255, blue.Blue);
+			Assert.AreEqual(0, blue.Alpha);
 
 			var alpha = color.WithAlpha(255);
-			Assert.Equal(0, alpha.Red);
-			Assert.Equal(0, alpha.Green);
-			Assert.Equal(0, alpha.Blue);
-			Assert.Equal(255, alpha.Alpha);
+			Assert.AreEqual(0, alpha.Red);
+			Assert.AreEqual(0, alpha.Green);
+			Assert.AreEqual(0, alpha.Blue);
+			Assert.AreEqual(255, alpha.Alpha);
 		}
 
-		[Fact]
+		[Test]
 		public void ColorRgbToHsl()
 		{
 			var tuples = new List<ToOtherColor> {
@@ -69,21 +69,21 @@ namespace SkiaSharp.Tests
 				float h, s, l;
 				rgb.ToHsl(out h, out s, out l);
 
-				Assert.Equal(other.Item1, h, Precision);
-				Assert.Equal(other.Item2, s, Precision);
-				Assert.Equal(other.Item3, l, Precision);
+				Assert.AreEqual(other.Item1, h, Precision);
+				Assert.AreEqual(other.Item2, s, Precision);
+				Assert.AreEqual(other.Item3, l, Precision);
 
 				// to RGB
 				SKColor back = SKColor.FromHsl(other.Item1, other.Item2, other.Item3);
 
-				Assert.Equal(rgb.Red, back.Red);
-				Assert.Equal(rgb.Green, back.Green);
-				Assert.Equal(rgb.Blue, back.Blue);
-				Assert.Equal(rgb.Alpha, back.Alpha);
+				Assert.AreEqual(rgb.Red, back.Red);
+				Assert.AreEqual(rgb.Green, back.Green);
+				Assert.AreEqual(rgb.Blue, back.Blue);
+				Assert.AreEqual(rgb.Alpha, back.Alpha);
 			}
 		}
 
-		[Fact]
+		[Test]
 		public void ColorRgbToHsv()
 		{
 			var tuples = new List<ToOtherColor> {
@@ -107,21 +107,21 @@ namespace SkiaSharp.Tests
 				float h, s, v;
 				rgb.ToHsv(out h, out s, out v);
 
-				Assert.Equal(other.Item1, h, Precision);
-				Assert.Equal(other.Item2, s, Precision);
-				Assert.Equal(other.Item3, v, Precision);
+				Assert.AreEqual(other.Item1, h, Precision);
+				Assert.AreEqual(other.Item2, s, Precision);
+				Assert.AreEqual(other.Item3, v, Precision);
 
 				// to RGB
 				SKColor back = SKColor.FromHsv(other.Item1, other.Item2, other.Item3);
 
-				Assert.Equal(rgb.Red, back.Red);
-				Assert.Equal(rgb.Green, back.Green);
-				Assert.Equal(rgb.Blue, back.Blue);
-				Assert.Equal(rgb.Alpha, back.Alpha);
+				Assert.AreEqual(rgb.Red, back.Red);
+				Assert.AreEqual(rgb.Green, back.Green);
+				Assert.AreEqual(rgb.Blue, back.Blue);
+				Assert.AreEqual(rgb.Alpha, back.Alpha);
 			}
 		}
 
-		[Fact]
+		[Test]
 		public void HexToColor()
 		{
 			var tuples = new List<Tuple<string, SKColor>> {
@@ -151,11 +151,11 @@ namespace SkiaSharp.Tests
 
 				SKColor color = SKColor.Parse(hex);
 
-				Assert.Equal(other, color);
+				Assert.AreEqual(other, color);
 			}
 		}
 
-		[Fact]
+		[Test]
 		public void InvalidHexToColor()
 		{
 			var tuples = new List<string> {
diff --git a/tests/Tests/SKDataTest.cs b/tests/Tests/SKDataTest.cs
index b3874610..c21ffcd4 100644
--- a/tests/Tests/SKDataTest.cs
+++ b/tests/Tests/SKDataTest.cs
@@ -1,6 +1,6 @@
 using System;
 using System.Runtime.InteropServices;
-using Xunit;
+using NUnit.Framework;
 
 namespace SkiaSharp.Tests
 {
@@ -8,16 +8,17 @@ namespace SkiaSharp.Tests
 	{
 		private readonly static byte[] OddData = new byte[] { 1, 3, 5, 7, 9 };
 
-		[Fact]
+		[Test]
 		public void ValidDataProperties()
 		{
 			var data = new SKData(OddData);
 
-			Assert.Equal(OddData.Length, data.Size);
-			Assert.Equal(OddData, data.ToArray());
+			Assert.AreEqual(OddData.Length, data.Size);
+			Assert.AreEqual(OddData, data.ToArray());
 		}
 
-		[Fact(Skip = "Doesn't work as it relies on memory being overwritten by an external process.")]
+		[Test]
+		[Ignore("Doesn't work as it relies on memory being overwritten by an external process.")]
 		public void DataDisposedReturnsInvalidStream()
 		{
 			// create data
@@ -28,14 +29,14 @@ namespace SkiaSharp.Tests
 
 			// nuke the data
 			data.Dispose();
-			Assert.Equal(IntPtr.Zero, data.Handle);
+			Assert.AreEqual(IntPtr.Zero, data.Handle);
 
 			// read the stream
 			var buffer = new byte[OddData.Length];
 			stream.Read(buffer, 0, buffer.Length);
 
 			// since the data was nuked, they will differ
-			Assert.NotEqual(OddData, buffer);
+			Assert.AreNotEqual(OddData, buffer);
 		}
 	}
 }
diff --git a/tests/Tests/SKManagedStreamTest.cs b/tests/Tests/SKManagedStreamTest.cs
index ee5f6b89..228030ba 100644
--- a/tests/Tests/SKManagedStreamTest.cs
+++ b/tests/Tests/SKManagedStreamTest.cs
@@ -1,13 +1,13 @@
 using System;
 using System.IO;
 using System.Linq;
-using Xunit;
+using NUnit.Framework;
 
 namespace SkiaSharp.Tests
 {
 	public class SKManagedStreamTest : SKTest
 	{
-		[Fact]
+		[Test]
 		public void ManagedStreamReadsByteCorrectly()
 		{
 			var data = new byte[1024];
@@ -20,25 +20,25 @@ namespace SkiaSharp.Tests
 			var skManagedStream = new SKManagedStream(stream);
 
 			skManagedStream.Rewind();
-			Assert.Equal(0, stream.Position);
-			Assert.Equal(0, skManagedStream.Position);
+			Assert.AreEqual(0, stream.Position);
+			Assert.AreEqual(0, skManagedStream.Position);
 
 			for (int i = 0; i < data.Length; i++)
 			{
 				skManagedStream.Position = i;
 
-				Assert.Equal(i, stream.Position);
-				Assert.Equal(i, skManagedStream.Position);
+				Assert.AreEqual(i, stream.Position);
+				Assert.AreEqual(i, skManagedStream.Position);
 
-				Assert.Equal((byte)(i % byte.MaxValue), data[i]);
-				Assert.Equal((byte)(i % byte.MaxValue), skManagedStream.ReadByte());
+				Assert.AreEqual((byte)(i % byte.MaxValue), data[i]);
+				Assert.AreEqual((byte)(i % byte.MaxValue), skManagedStream.ReadByte());
 
-				Assert.Equal(i + 1, stream.Position);
-				Assert.Equal(i + 1, skManagedStream.Position);
+				Assert.AreEqual(i + 1, stream.Position);
+				Assert.AreEqual(i + 1, skManagedStream.Position);
 			}
 		}
 
-		[Fact]
+		[Test]
 		public void ManagedStreamReadsChunkCorrectly()
 		{
 			var data = new byte[1024];
@@ -51,16 +51,16 @@ namespace SkiaSharp.Tests
 			var skManagedStream = new SKManagedStream(stream);
 
 			skManagedStream.Rewind();
-			Assert.Equal(0, stream.Position);
-			Assert.Equal(0, skManagedStream.Position);
+			Assert.AreEqual(0, stream.Position);
+			Assert.AreEqual(0, skManagedStream.Position);
 
 			var buffer = new byte[data.Length / 2];
 			skManagedStream.Read(buffer, buffer.Length);
 
-			Assert.Equal(data.Take(buffer.Length), buffer);
+			Assert.AreEqual(data.Take(buffer.Length), buffer);
 		}
 
-		[Fact]
+		[Test]
 		public void ManagedStreamReadsOffsetChunkCorrectly()
 		{
 			var data = new byte[1024];
@@ -79,11 +79,11 @@ namespace SkiaSharp.Tests
 			var buffer = new byte[data.Length];
 			var taken = skManagedStream.Read(buffer, buffer.Length);
 
-			Assert.Equal(data.Length - offset, taken);
+			Assert.AreEqual(data.Length - offset, taken);
 
 			var resultData = data.Skip(offset).Take(buffer.Length).ToArray();
 			resultData = resultData.Concat(Enumerable.Repeat<byte>(0, offset)).ToArray();
-			Assert.Equal(resultData, buffer);
+			Assert.AreEqual(resultData, buffer);
 		}
 	}
 }
diff --git a/tests/Tests/SKPaintTest.cs b/tests/Tests/SKPaintTest.cs
index 25cc25d7..4e5c1c92 100644
--- a/tests/Tests/SKPaintTest.cs
+++ b/tests/Tests/SKPaintTest.cs
@@ -1,12 +1,12 @@
 using System;
 using System.Linq;
-using Xunit;
+using NUnit.Framework;
 
 namespace SkiaSharp.Tests
 {
 	public class SKPaintTest : SKTest
 	{
-		[Fact]
+		[Test]
 		public void StrokePropertyValuesAreCorrect()
 		{
 			var paint = new SKPaint();
@@ -18,7 +18,7 @@ namespace SkiaSharp.Tests
 			Assert.False(paint.IsStroke);
 		}
 
-		[Fact]
+		[Test]
 		public void GetFillPathIsWorking()
 		{
 			var paint = new SKPaint();
@@ -32,11 +32,11 @@ namespace SkiaSharp.Tests
 			var isFilled = paint.GetFillPath(path, fillPath);
 
 			Assert.True(isFilled);
-			Assert.Equal(rect, fillPath.Bounds);
-			Assert.Equal(4, fillPath.PointCount);
+			Assert.AreEqual(rect, fillPath.Bounds);
+			Assert.AreEqual(4, fillPath.PointCount);
 		}
 
-		[Fact]
+		[Test]
 		public void GetFillPathIsWorkingWithLine()
 		{
 			var paint = new SKPaint();
@@ -52,17 +52,17 @@ namespace SkiaSharp.Tests
 			var isFilled = paint.GetFillPath(path, fillPath);
 
 			Assert.True(isFilled);
-			Assert.Equal(thinRect, fillPath.Bounds);
-			Assert.Equal(2, fillPath.PointCount);
+			Assert.AreEqual(thinRect, fillPath.Bounds);
+			Assert.AreEqual(2, fillPath.PointCount);
 
 			paint.StrokeWidth = 20;
 			paint.IsStroke = true;
 			isFilled = paint.GetFillPath(path, fillPath);
 
 			Assert.True(isFilled);
-			Assert.Equal(rect, fillPath.Bounds);
-			Assert.Equal(4 + 1, fillPath.PointCount); // +1 becuase the last point is the same as the first
-			Assert.Equal(4, fillPath.Points.Distinct().Count());
+			Assert.AreEqual(rect, fillPath.Bounds);
+			Assert.AreEqual(4 + 1, fillPath.PointCount); // +1 becuase the last point is the same as the first
+			Assert.AreEqual(4, fillPath.Points.Distinct().Count());
 		}
 	}
 }
diff --git a/tests/Tests/SKPathTest.cs b/tests/Tests/SKPathTest.cs
index aa6984cd..2fb41e69 100644
--- a/tests/Tests/SKPathTest.cs
+++ b/tests/Tests/SKPathTest.cs
@@ -1,6 +1,6 @@
 using System;
 using System.Collections.Generic;
-using Xunit;
+using NUnit.Framework;
 
 using ParsePathTest = System.Tuple<System.String, SkiaSharp.SKRect>;
 
@@ -34,10 +34,10 @@ namespace SkiaSharp.Tests
 			var str2 = path2.ToSvgPathData ();
 			Assert.NotNull (str2);
 
-			Assert.Equal (str, str2);
+			Assert.AreEqual (str, str2);
 		}
 
-		[Fact]
+		[Test]
 		public void PathPointsAreCorrect()
 		{
 			using (var path = new SKPath ()) {
@@ -58,19 +58,19 @@ namespace SkiaSharp.Tests
 				path.Close ();
 
 				// the right number/count
-				Assert.Equal (25, path.PointCount);
-				Assert.Equal (25, path.Points.Length);
+				Assert.AreEqual (25, path.PointCount);
+				Assert.AreEqual (25, path.Points.Length);
 
 				// the right value
-				Assert.Equal (new SKPoint (68.6763107f, 56.0058575f), path.GetPoint (1));
-				Assert.Equal (new SKPoint (68.6763107f, 56.0058575f), path.Points [1]);
+				Assert.AreEqual (new SKPoint (68.6763107f, 56.0058575f), path.GetPoint (1));
+				Assert.AreEqual (new SKPoint (68.6763107f, 56.0058575f), path.Points [1]);
 
 				// the right segment masks
-				Assert.Equal (SKPathSegmentMask.Cubic | SKPathSegmentMask.Line, path.SegmentMasks);
+				Assert.AreEqual (SKPathSegmentMask.Cubic | SKPathSegmentMask.Line, path.SegmentMasks);
 			}
 		}
 
-		[Fact]
+		[Test]
 		public void PathContainsPoint()
 		{
 			using (var path = new SKPath ()) {
@@ -81,18 +81,18 @@ namespace SkiaSharp.Tests
 			}
 		}
 
-		[Fact]
+		[Test]
 		public void GetLastPoint()
 		{
 			using (var path = new SKPath ()) {
 				path.MoveTo (0, 0);
 				path.LineTo (10, 20);
 
-				Assert.Equal (new SKPoint(10, 20), path.LastPoint);
+				Assert.AreEqual (new SKPoint(10, 20), path.LastPoint);
 			}
 		}
 
-		[Fact]
+		[Test]
 		public void ThumbtackShapeIsConcave ()
 		{
 			// based on test_skbug_3469
@@ -102,11 +102,11 @@ namespace SkiaSharp.Tests
 				path.QuadTo (20, 50, 80, 50);
 				path.QuadTo (20, 50, 20, 80);
 
-				Assert.Equal (SKPathConvexity.Concave, path.Convexity);
+				Assert.AreEqual (SKPathConvexity.Concave, path.Convexity);
 			}
 		}
 
-		[Fact]
+		[Test]
 		public void PathConsistentAfterClose ()
 		{
 			// based on test_path_close_issue1474
@@ -123,8 +123,8 @@ namespace SkiaSharp.Tests
 				path.RLineTo (50, 50);  // This should go to 50,50.
 
 				last = path.LastPoint;
-				Assert.Equal (50, last.X);
-				Assert.Equal (50, last.Y);
+				Assert.AreEqual (50, last.X);
+				Assert.AreEqual (50, last.Y);
 
 				// Test rQuadTo().
 				path.Rewind ();
@@ -134,8 +134,8 @@ namespace SkiaSharp.Tests
 				path.RQuadTo (50, 50, 75, 75);
 
 				last = path.LastPoint;
-				Assert.Equal (75, last.X);
-				Assert.Equal (75, last.Y);
+				Assert.AreEqual (75, last.X);
+				Assert.AreEqual (75, last.Y);
 
 				// Test rConicTo().
 				path.Rewind ();
@@ -145,8 +145,8 @@ namespace SkiaSharp.Tests
 				path.RConicTo (50, 50, 85, 85, 2);
 
 				last = path.LastPoint;
-				Assert.Equal (85, last.X);
-				Assert.Equal (85, last.Y);
+				Assert.AreEqual (85, last.X);
+				Assert.AreEqual (85, last.Y);
 
 				// Test rCubicTo().
 				path.Rewind ();
@@ -156,12 +156,12 @@ namespace SkiaSharp.Tests
 				path.RCubicTo (50, 50, 85, 85, 95, 95);
 
 				last = path.LastPoint;
-				Assert.Equal (95, last.X);
-				Assert.Equal (95, last.Y);
+				Assert.AreEqual (95, last.X);
+				Assert.AreEqual (95, last.Y);
 			}
 		}
 
-		[Fact]
+		[Test]
 		public void ParsePathReturnsValidPath ()
 		{
 			// based on ParsePath
@@ -170,7 +170,7 @@ namespace SkiaSharp.Tests
 				var path = SKPath.ParseSvgPathData (test.Item1);
 
 				Assert.NotNull (path);
-				Assert.Equal (test.Item2, path.Bounds);
+				Assert.AreEqual (test.Item2, path.Bounds);
 
 				TestToFromSvgPath (path);
 			}
@@ -188,7 +188,7 @@ namespace SkiaSharp.Tests
 			}
 		}
 
-		[Fact]
+		[Test]
 		public void PathBoundsAndRegionBoundsMatch ()
 		{
 			var path = new SKPath ();
@@ -196,22 +196,22 @@ namespace SkiaSharp.Tests
 			path.LineTo (90, 90);
 
 			var bounds = path.Bounds;
-			Assert.Equal (10f, bounds.Left);
-			Assert.Equal (10f, bounds.Top);
-			Assert.Equal (90f, bounds.Right);
-			Assert.Equal (90f, bounds.Bottom);
+			Assert.AreEqual (10f, bounds.Left);
+			Assert.AreEqual (10f, bounds.Top);
+			Assert.AreEqual (90f, bounds.Right);
+			Assert.AreEqual (90f, bounds.Bottom);
 
 			var region = new SKRegion ();
 			region.SetRect (new SKRectI (10, 10, 90, 90));
 
 			var regionBounds = region.Bounds;
-			Assert.Equal (10f, regionBounds.Left);
-			Assert.Equal (10f, regionBounds.Top);
-			Assert.Equal (90f, regionBounds.Right);
-			Assert.Equal (90f, regionBounds.Bottom);
+			Assert.AreEqual (10f, regionBounds.Left);
+			Assert.AreEqual (10f, regionBounds.Top);
+			Assert.AreEqual (90f, regionBounds.Right);
+			Assert.AreEqual (90f, regionBounds.Bottom);
 		}
 
-		[Fact]
+		[Test]
 		public void BoundsAndTightBoundAreCorrect ()
 		{
 			const int Precision = 6;
@@ -222,20 +222,20 @@ namespace SkiaSharp.Tests
 				path.RCubicTo (-34.64102137842175f, 19.9999998f, 0f, 40f, 0f, 40f);
 
 				var bounds = path.Bounds;
-				Assert.Equal (-34.641022f, bounds.Left, Precision);
-				Assert.Equal (-25.814698f, bounds.Top, Precision);
-				Assert.Equal (-6.215782e-07f, bounds.Right, Precision);
-				Assert.Equal (14.185303f, bounds.Bottom, Precision);
+				Assert.AreEqual (-34.641022f, bounds.Left, Precision);
+				Assert.AreEqual (-25.814698f, bounds.Top, Precision);
+				Assert.AreEqual (-6.215782e-07f, bounds.Right, Precision);
+				Assert.AreEqual (14.185303f, bounds.Bottom, Precision);
 
 				var tightBounds = path.TightBounds;
-				Assert.Equal (-15.396009f, tightBounds.Left, Precision);
-				Assert.Equal (-25.814698f, tightBounds.Top, Precision);
-				Assert.Equal (0f, tightBounds.Right, Precision);
-				Assert.Equal (14.185303f, tightBounds.Bottom, Precision);
+				Assert.AreEqual (-15.396009f, tightBounds.Left, Precision);
+				Assert.AreEqual (-25.814698f, tightBounds.Top, Precision);
+				Assert.AreEqual (0f, tightBounds.Right, Precision);
+				Assert.AreEqual (14.185303f, tightBounds.Bottom, Precision);
 			}
 		}
 
-		[Fact]
+		[Test]
 		public void MeasuringSegementsWorks ()
 		{
 			using (SKPath path = new SKPath ())
@@ -243,18 +243,18 @@ namespace SkiaSharp.Tests
 				path.MoveTo (10f, 10f);
 				path.LineTo (110f, 10f);
 
-				Assert.Equal (SKPathSegmentMask.Line, path.SegmentMasks);
+				Assert.AreEqual (SKPathSegmentMask.Line, path.SegmentMasks);
 
 				var measure = new SKPathMeasure (path);
 
-				Assert.Equal (100f, measure.Length);
+				Assert.AreEqual (100f, measure.Length);
 
 				var segment = new SKPath ();
 				var result = measure.GetSegment (20, 50, segment, true);
 				Assert.True (result);
-				Assert.Equal (2, segment.PointCount);
-				Assert.Equal (new SKPoint (30, 10), segment.Points [0]);
-				Assert.Equal (new SKPoint (60, 10), segment.Points [1]);
+				Assert.AreEqual (2, segment.PointCount);
+				Assert.AreEqual (new SKPoint (30, 10), segment.Points [0]);
+				Assert.AreEqual (new SKPoint (60, 10), segment.Points [1]);
 			}
 		}
 	}
diff --git a/tests/Tests/SKStringTest.cs b/tests/Tests/SKStringTest.cs
index a043e0c0..9cef0b87 100644
--- a/tests/Tests/SKStringTest.cs
+++ b/tests/Tests/SKStringTest.cs
@@ -1,20 +1,20 @@
 using System;
 using System.IO;
-using Xunit;
+using NUnit.Framework;
 
 namespace SkiaSharp.Tests
 {
 	public class SKStringTest : SKTest
 	{
-		[Fact]
+		[Test]
 		public void StringIsMarshaledCorrectly ()
 		{
 			using (var typeface = SKTypeface.FromFile (Path.Combine (PathToFonts, "SpiderSymbol.ttf")))
 			{
 				if (IsLinux) // see issue #225
-					Assert.Equal("", typeface.FamilyName);
+					Assert.AreEqual("", typeface.FamilyName);
 				else
-					Assert.Equal ("SpiderSymbol", typeface.FamilyName);
+					Assert.AreEqual ("SpiderSymbol", typeface.FamilyName);
 			}
 		}
 	}
diff --git a/tests/Tests/SKSurfaceTest.cs b/tests/Tests/SKSurfaceTest.cs
index bca44b01..8c80674e 100644
--- a/tests/Tests/SKSurfaceTest.cs
+++ b/tests/Tests/SKSurfaceTest.cs
@@ -1,7 +1,7 @@
 using System;
 using System.Drawing;
 using System.Drawing.Imaging;
-using Xunit;
+using NUnit.Framework;
 
 namespace SkiaSharp.Tests
 {
@@ -35,7 +35,7 @@ namespace SkiaSharp.Tests
 			bitmap.UnlockBits(data);
 		}
 
-		[Fact]
+		[Test]
 		public void SurfaceCanvasReturnTheSameInstance()
 		{
 			Draw(surface =>
@@ -46,14 +46,14 @@ namespace SkiaSharp.Tests
 				Assert.NotNull(skcanvas1);
 				Assert.NotNull(skcanvas2);
 
-				Assert.Equal(skcanvas1, skcanvas2);
+				Assert.AreEqual(skcanvas1, skcanvas2);
 				Assert.True(skcanvas1 == skcanvas2);
 
-				Assert.Same(skcanvas1, skcanvas2);
+				Assert.AreSame(skcanvas1, skcanvas2);
 			});
 		}
 
-		[Fact]
+		[Test]
 		public void SecondSurfaceWasCreatedDifferent()
 		{
 			var data = bitmap.LockBits(new Rectangle(0, 0, width, height), ImageLockMode.WriteOnly, bitmap.PixelFormat);
@@ -64,8 +64,8 @@ namespace SkiaSharp.Tests
 			Assert.NotNull(surface1);
 			Assert.NotNull(surface2);
 
-			Assert.NotEqual(surface1, surface2);
-			Assert.NotEqual(surface1.Handle, surface2.Handle);
+			Assert.AreNotEqual(surface1, surface2);
+			Assert.AreNotEqual(surface1.Handle, surface2.Handle);
 
 			surface1.Dispose();
 			surface2.Dispose();
@@ -73,7 +73,7 @@ namespace SkiaSharp.Tests
 			bitmap.UnlockBits(data);
 		}
 
-		[Fact]
+		[Test]
 		public void SurfaceWasCreated()
 		{
 			var data = bitmap.LockBits(new Rectangle(0, 0, width, height), ImageLockMode.WriteOnly, bitmap.PixelFormat);
@@ -81,11 +81,11 @@ namespace SkiaSharp.Tests
 			var surface = SKSurface.Create(width, height, SKImageInfo.PlatformColorType, SKAlphaType.Premul, data.Scan0, data.Stride);
 
 			Assert.NotNull(surface);
-			Assert.NotEqual(IntPtr.Zero, surface.Handle);
+			Assert.AreNotEqual(IntPtr.Zero, surface.Handle);
 
 			surface.Dispose();
 
-			Assert.Equal(IntPtr.Zero, surface.Handle);
+			Assert.AreEqual(IntPtr.Zero, surface.Handle);
 
 			bitmap.UnlockBits(data);
 		}
diff --git a/tests/Tests/SKSvgTest.cs b/tests/Tests/SKSvgTest.cs
index baa2b766..628c9721 100644
--- a/tests/Tests/SKSvgTest.cs
+++ b/tests/Tests/SKSvgTest.cs
@@ -1,13 +1,13 @@
 using System;
 using System.IO;
-using Xunit;
+using NUnit.Framework;
 using System.Xml.Linq;
 
 namespace SkiaSharp.Tests
 {
 	public class SKSvgTest : SKTest
 	{
-		[Fact]
+		[Test]
 		public void LoadSvgCanvasSize()
 		{
 			var path = Path.Combine(PathToImages, "logos.svg");
@@ -15,10 +15,10 @@ namespace SkiaSharp.Tests
 			var svg = new SKSvg();
 			svg.Load(path);
 
-			Assert.Equal(new SKSize(300, 300), svg.CanvasSize);
+			Assert.AreEqual(new SKSize(300, 300), svg.CanvasSize);
 		}
 
-		[Fact]
+		[Test]
 		public void LoadSvgCustomCanvasSize()
 		{
 			var path = Path.Combine(PathToImages, "logos.svg");
@@ -26,10 +26,10 @@ namespace SkiaSharp.Tests
 			var svg = new SKSvg(new SKSize(150, 150));
 			svg.Load(path);
 
-			Assert.Equal(new SKSize(150, 150), svg.CanvasSize);
+			Assert.AreEqual(new SKSize(150, 150), svg.CanvasSize);
 		}
 
-		[Fact]
+		[Test]
 		public void SvgLoadsToBitmap()
 		{
 			var path = Path.Combine(PathToImages, "logos.svg");
@@ -43,10 +43,10 @@ namespace SkiaSharp.Tests
 			canvas.DrawPicture(svg.Picture);
 			canvas.Flush();
 
-			Assert.Equal(background, bmp.GetPixel(0, 0));
+			Assert.AreEqual(background, bmp.GetPixel(0, 0));
 		}
 
-		[Fact]
+		[Test]
 		public void SvgCanvasCreatesValidDrawing()
 		{
 			using (var stream = new MemoryStream())
@@ -74,23 +74,23 @@ namespace SkiaSharp.Tests
 
 				var ns = (XNamespace)"http://www.w3.org/2000/svg";
 
-				Assert.Equal(ns, svg.GetDefaultNamespace());
-				Assert.Equal("200", svg.Attribute("width").Value);
-				Assert.Equal("150", svg.Attribute("height").Value);
+				Assert.AreEqual(ns, svg.GetDefaultNamespace());
+				Assert.AreEqual("200", svg.Attribute("width").Value);
+				Assert.AreEqual("150", svg.Attribute("height").Value);
 
 				var rect = svg.Element(ns + "rect");
-				Assert.Equal("rgb(0,0,255)", rect.Attribute("fill").Value);
-				Assert.Equal("50", rect.Attribute("x").Value);
-				Assert.Equal("70", rect.Attribute("y").Value);
-				Assert.Equal("100", rect.Attribute("width").Value);
-				Assert.Equal("30", rect.Attribute("height").Value);
+				Assert.AreEqual("rgb(0,0,255)", rect.Attribute("fill").Value);
+				Assert.AreEqual("50", rect.Attribute("x").Value);
+				Assert.AreEqual("70", rect.Attribute("y").Value);
+				Assert.AreEqual("100", rect.Attribute("width").Value);
+				Assert.AreEqual("30", rect.Attribute("height").Value);
 
 				var ellipse = svg.Element(ns + "ellipse");
-				Assert.Equal("rgb(255,0,0)", ellipse.Attribute("fill").Value);
-				Assert.Equal("100", ellipse.Attribute("cx").Value);
-				Assert.Equal("85", ellipse.Attribute("cy").Value);
-				Assert.Equal("50", ellipse.Attribute("rx").Value);
-				Assert.Equal("15", ellipse.Attribute("ry").Value);
+				Assert.AreEqual("rgb(255,0,0)", ellipse.Attribute("fill").Value);
+				Assert.AreEqual("100", ellipse.Attribute("cx").Value);
+				Assert.AreEqual("85", ellipse.Attribute("cy").Value);
+				Assert.AreEqual("50", ellipse.Attribute("rx").Value);
+				Assert.AreEqual("15", ellipse.Attribute("ry").Value);
 			}
 		}
 	}
diff --git a/tests/Tests/SKTest.cs b/tests/Tests/SKTest.cs
index 129bf751..41127aee 100644
--- a/tests/Tests/SKTest.cs
+++ b/tests/Tests/SKTest.cs
@@ -2,17 +2,19 @@
 using System.IO;
 using System.Reflection;
 using System.Runtime.InteropServices;
-using Xunit;
+using NUnit.Framework;
+
+[assembly: Parallelizable(ParallelScope.Fixtures)]
 
 namespace SkiaSharp.Tests
 {
 	public abstract class SKTest
 	{
-#if NET_STANDARD
 		protected static readonly string PathToAssembly = Path.GetDirectoryName(typeof(SKTest).GetTypeInfo().Assembly.Location);
 		protected static readonly string PathToFonts = Path.Combine(PathToAssembly, "fonts");
 		protected static readonly string PathToImages = Path.Combine(PathToAssembly, "images");
 
+#if NET_STANDARD
 		protected static bool IsLinux => RuntimeInformation.IsOSPlatform(OSPlatform.Linux);
 		protected static bool IsMac => RuntimeInformation.IsOSPlatform(OSPlatform.OSX);
 		protected static bool IsUnix => IsLinux || IsMac;
@@ -45,9 +47,6 @@ namespace SkiaSharp.Tests
 			}
 		}
 
-		protected const string PathToFonts = "fonts";
-		protected const string PathToImages = "images";
-
 		protected static bool IsMac => MacPlatformDetector.IsMac.Value;
 		protected static bool IsUnix => Environment.OSVersion.Platform == PlatformID.Unix || IsMac;
 		protected static bool IsLinux => IsUnix && !IsMac;
diff --git a/tests/Tests/SKTypefaceTest.cs b/tests/Tests/SKTypefaceTest.cs
index cda3399f..7036853d 100644
--- a/tests/Tests/SKTypefaceTest.cs
+++ b/tests/Tests/SKTypefaceTest.cs
@@ -1,5 +1,5 @@
 using System;
-using Xunit;
+using NUnit.Framework;
 using System.IO;
 
 namespace SkiaSharp.Tests
@@ -22,21 +22,21 @@ namespace SkiaSharp.Tests
 			0x02, 0x00, 0x24, 0x00, 0x44,
 		};
 
-		[Fact]
+		[Test]
 		public void NullInWrongFileName()
 		{
 			Assert.Null(SKTypeface.FromFile(Path.Combine(PathToFonts, "font that doesn't exist.ttf")));
 		}
 
-		[Fact]
+		[Test]
 		public void TestFamilyName()
 		{
 			using (var typeface = SKTypeface.FromFile(Path.Combine(PathToFonts, "Roboto2-Regular_NoEmbed.ttf")))
 			{
 				if (IsLinux) // see issue #225
-					Assert.Equal("", typeface.FamilyName);
+					Assert.AreEqual("", typeface.FamilyName);
 				else
-					Assert.Equal("Roboto2", typeface.FamilyName);
+					Assert.AreEqual("Roboto2", typeface.FamilyName);
 			}
 		}
 
@@ -58,46 +58,46 @@ namespace SkiaSharp.Tests
 				(UInt32)(v[3]) << 00;
 		}
 
-		[Fact]
+		[Test]
 		public void TestGetTableTags()
 		{
 			using (var typeface = SKTypeface.FromFile(Path.Combine(PathToFonts, "SpiderSymbol.ttf")))
 			{
 				if (IsLinux) // see issue #225
-					Assert.Equal("", typeface.FamilyName);
+					Assert.AreEqual("", typeface.FamilyName);
 				else
-					Assert.Equal("SpiderSymbol", typeface.FamilyName);
+					Assert.AreEqual("SpiderSymbol", typeface.FamilyName);
 				var tables = typeface.GetTableTags();
-				Assert.Equal(ExpectedTablesSpiderFont.Length, tables.Length);
+				Assert.AreEqual(ExpectedTablesSpiderFont.Length, tables.Length);
 
 				for (int i = 0; i < tables.Length; i++) {
-					Assert.Equal(ExpectedTablesSpiderFont[i], GetReadableTag(tables[i]));
+					Assert.AreEqual(ExpectedTablesSpiderFont[i], GetReadableTag(tables[i]));
 				}
 			}
 		}
 
-		[Fact]
+		[Test]
 		public void TestGetTableData()
 		{
 			using (var typeface = SKTypeface.FromFile(Path.Combine(PathToFonts, "ReallyBigA.ttf")))
 			{
 				if (IsLinux) // see issue #225
-					Assert.Equal("", typeface.FamilyName);
+					Assert.AreEqual("", typeface.FamilyName);
 				else
-					Assert.Equal("ReallyBigA", typeface.FamilyName);
+					Assert.AreEqual("ReallyBigA", typeface.FamilyName);
 				var tables = typeface.GetTableTags();
 
 				for (int i = 0; i < tables.Length; i++) {
 					byte[] tableData = typeface.GetTableData(tables[i]);
-					Assert.Equal(ExpectedTableLengthsReallyBigAFont[i], tableData.Length);
+					Assert.AreEqual(ExpectedTableLengthsReallyBigAFont[i], tableData.Length);
 				}
 
-				Assert.Equal(ExpectedTableDataPostReallyBigAFont, typeface.GetTableData(GetIntTag("post")));
+				Assert.AreEqual(ExpectedTableDataPostReallyBigAFont, typeface.GetTableData(GetIntTag("post")));
 
 			}
 		}
 
-		[Fact]
+		[Test]
 		public void TestFontManagerMatchCharacter()
 		{
 			var fonts = SKFontManager.Default;
@@ -106,15 +106,15 @@ namespace SkiaSharp.Tests
 			using (var typeface = fonts.MatchCharacter(emojiChar))
 			{
 				if (IsLinux)
-					Assert.Equal("Symbola", typeface.FamilyName);
+					Assert.AreEqual("Symbola", typeface.FamilyName);
 				else if (IsMac)
-					Assert.Equal("Apple Color Emoji", typeface.FamilyName);
+					Assert.AreEqual("Apple Color Emoji", typeface.FamilyName);
 				else if (IsWindows)
-					Assert.Equal("Segoe UI Emoji", typeface.FamilyName);
+					Assert.AreEqual("Segoe UI Emoji", typeface.FamilyName);
 			}
 		}
 
-		[Fact]
+		[Test]
 		public void ExceptionInInvalidGetTableData()
 		{
 			using (var typeface = SKTypeface.FromFile(Path.Combine(PathToFonts, "Distortable.ttf")))
@@ -123,7 +123,7 @@ namespace SkiaSharp.Tests
 			}
 		}
 
-		[Fact]
+		[Test]
 		public void TestTryGetTableData()
 		{
 			using (var typeface = SKTypeface.FromFile(Path.Combine(PathToFonts, "ReallyBigA.ttf")))
@@ -132,15 +132,15 @@ namespace SkiaSharp.Tests
 				for (int i = 0; i < tables.Length; i++) {
 					byte[] tableData;
 					Assert.True(typeface.TryGetTableData(tables[i], out tableData));
-					Assert.Equal(ExpectedTableLengthsReallyBigAFont[i], tableData.Length);
+					Assert.AreEqual(ExpectedTableLengthsReallyBigAFont[i], tableData.Length);
 				}
 
-				Assert.Equal(ExpectedTableDataPostReallyBigAFont, typeface.GetTableData(GetIntTag("post")));
+				Assert.AreEqual(ExpectedTableDataPostReallyBigAFont, typeface.GetTableData(GetIntTag("post")));
 
 			}
 		}
 
-		[Fact]
+		[Test]
 		public void InvalidTryGetTableData()
 		{
 			using (var typeface = SKTypeface.FromFile(Path.Combine(PathToFonts, "Distortable.ttf")))
diff --git a/tools/packages.config b/tools/packages.config
index 0d05ae1d..27f2c676 100644
--- a/tools/packages.config
+++ b/tools/packages.config
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
     <package id="Cake" version="0.17.0" />
-    <package id="XUnit.Runner.Console" version="2.1.0" />
+    <package id="NUnit.Console" version="3.6.0" />
     <package id="Microsoft.DotNet.BuildTools.GenAPI" version="1.0.0-beta-00081" />
 </packages>